How to use getImplicitWaitTimeout method of org.openqa.selenium.Interface WebDriver.Timeouts class

This should do the trick:

driver.switchTo().alert().accept();

When using PageFactory in PageObjectModel if you expect the element to be invisible, you can use the Explicit Wait support with a normal locator factory and use either of the following solutions:

invisibilityOfElementLocated()

invisibilityOfElementLocated() is the implementation for an expectation for checking that an element is either invisible or not present on the DOM. It is defined as follows:

public static ExpectedCondition<java.lang.Boolean> invisibilityOfElementLocated(By locator)
An expectation for checking that an element is either invisible or not present on the DOM.

Parameters:
    locator - used to find the element

Returns:
    true if the element is not displayed or the element doesn't exist or stale element

• Code Block:

  import org.openqa.selenium.WebDriver;
  import org.openqa.selenium.WebElement;
  import org.openqa.selenium.support.FindBy;
  import org.openqa.selenium.support.PageFactory;
  import org.openqa.selenium.support.ui.WebDriverWait;
  
  public class fooPage {
  
      WebDriver driver;
      public fooPage(WebDriver driver)
      {
          PageFactory.initElements(driver, this);
      }
  
      //you don't need this
      //@FindBy(css= '#loading-content')
      //WebElement pleaseWait;
  
      public void foo()
      {
          Boolean bool = new WebDriverWait(driver, 20).until(ExpectedConditions.invisibilityOfElementLocated(By.cssSelector('#loading-content')));
          //other lines of code
      }
  }
  

As an alternative you can also use the invisibilityOf() method as follows:

invisibilityOf()

invisibilityOf() is the implementation for an expectation for checking the element to be invisible. It is defined as follows:

public static ExpectedCondition<java.lang.Boolean> invisibilityOf(WebElement element)
An expectation for checking the element to be invisible

Parameters:
    element - used to check its invisibility

Returns:
    Boolean true when elements is not visible anymore

• Code Block:

  import org.openqa.selenium.WebDriver;
  import org.openqa.selenium.WebElement;
  import org.openqa.selenium.support.FindBy;
  import org.openqa.selenium.support.PageFactory;
  import org.openqa.selenium.support.ui.WebDriverWait;
  
  public class fooPage {
  
      WebDriver driver;
      public fooPage(WebDriver driver)
      {
          PageFactory.initElements(driver, this);
      }
  
  
      @FindBy(css= '#loading-content')
      WebElement pleaseWait;
  
      public void foo()
      {
          Boolean bool = new WebDriverWait(driver, 20).until(ExpectedConditions.invisibilityOf(fooPage.getWebElement()));
          //other lines of code
      }
  
      public WebElement getWebElement()
      {
          return pleaseWait;
      }
  }
  

You can find a detailed discussion in How to use explicit waits with PageFactory fields and the PageObject pattern

This should select the element you want

./ancestor::div[contains(concat(' ', @class, ' '), ' x-grid-view ')][1]

In plain English: Of all the ancestor div elements that have ' x-grid-view ' in their class, select the first (closest) one.

Notes:

• I concat spaces as a defensive measure to prevent partial matches.
• current() is an XSLT function, not an XPath one. It has no meaning outside of XSLT. The current node is expressed as . in XPath.

It is a very stupid mistake that maybe someone new to testNG may make...

@BeforeGroups("regression") 

This is a wrong usage.. The correct usage should be:

@BeforeGroups(groups = "regression")

Took me two days!!

You can use WebDriverWait. From docs example:

 (new WebDriverWait(driver, 10)).until(new ExpectedCondition<Boolean>() {
            public Boolean apply(WebDriver d) {
                return d.findElement(...).getText().length() != 0;
            }
        });

There is nothing wrong at your end.

The URL http://localhost:4444/wd/hub is designed such that it expects a PAYLOAD with your operation. Since you haven't provided the desired payload you are seeing a NullPointerException.

This URL is not supposed to be opened up in a browser. Its meant to be consumed via Http operations with a proper payload that adheres to the Selenium w3c spec

UPDATED POST 05-30-2021

This is the hardest question that I have every tried to answer on Stack Overflow. Because it involved the interactions of several code bases written in multiple languages (Java, Rust and C++). This complexity made the question potentially unsolvable.

My last crack at this likely unsolvable question:

Within the code in your question you are modifying the file user.js This file is still used by Selenium.

public FirefoxProfile() {
    this(null);
  }

  /**
   * Constructs a firefox profile from an existing profile directory.
   * <p>
   * Users who need this functionality should consider using a named profile.
   *
   * @param profileDir The profile directory to use as a model.
   */
  public FirefoxProfile(File profileDir) {
    this(null, profileDir);
  }

  @Beta
  protected FirefoxProfile(Reader defaultsReader, File profileDir) {
    if (defaultsReader == null) {
      defaultsReader = onlyOverrideThisIfYouKnowWhatYouAreDoing();
    }

    additionalPrefs = new Preferences(defaultsReader);

    model = profileDir;
    verifyModel(model);

    File prefsInModel = new File(model, "user.js");
    if (prefsInModel.exists()) {
      StringReader reader = new StringReader("{\"frozen\": {}, \"mutable\": {}}");
      Preferences existingPrefs = new Preferences(reader, prefsInModel);
      acceptUntrustedCerts = getBooleanPreference(existingPrefs, ACCEPT_UNTRUSTED_CERTS_PREF, true);
      untrustedCertIssuer = getBooleanPreference(existingPrefs, ASSUME_UNTRUSTED_ISSUER_PREF, true);
      existingPrefs.addTo(additionalPrefs);
    } else {
      acceptUntrustedCerts = true;
      untrustedCertIssuer = true;
    }

    // This is not entirely correct but this is not stored in the profile
    // so for now will always be set to false.
    loadNoFocusLib = false;

    try {
      defaultsReader.close();
    } catch (IOException e) {
      throw new WebDriverException(e);
    }
  }

So in theory you should be able to modify capabilities.rs in the geckodriver source code. That file contains the temp_dir.

As I stated this in only a theory, because when I looked at the Firefox source, which has temp_dir spread throughout the code base.

ORIGINAL POST 05-26-2021

I'm not sure that you can prevent Selenium from creating a temporary Firefox Profile.

From the gecko documents:

"Profiles are created in the systems temporary folder. This is also where the encoded profile is extracted when profile is provided. By default geckodriver will create a new profile in this location."

The only solution that I see at the moment would require you modify the Geckodriver source files to prevent the creation of temporary folders/profiles.

I'm currently looking at the source. These files might be the correct ones, but I need to look at the source more:

• https://searchfox.org/mozilla-central/source/browser/app/profile/firefox.js

• https://searchfox.org/mozilla-central/source/testing/mozbase/mozprofile/mozprofile/profile.py

Here are some other files that need to be combed through:

https://searchfox.org/mozilla-central/search?q=tempfile&path=

This looks promising:

https://searchfox.org/mozilla-central/source/testing/geckodriver/doc/Profiles.md

"geckodriver uses [profiles] to instrument Firefox’ behaviour. The user will usually rely on geckodriver to generate a temporary, throwaway profile. These profiles are deleted when the WebDriver session expires.

In cases where the user needs to use custom, prepared profiles, geckodriver will make modifications to the profile that ensures correct behaviour. See [Automation preferences] below on the precedence of user-defined preferences in this case.

Custom profiles can be provided two different ways:

1. by appending --profile /some/location to the [args capability], which will instruct geckodriver to use the profile in-place;

I found this question on trying to do this: how do I use an existing profile in-place with Selenium Webdriver?

Also here is an issue that was raised in selenium on Github concerning the temp directory. https://github.com/SeleniumHQ/selenium/issues/8645

Looking through the source of geckodriver v0.29.1 I found a file where the profile is loaded.

source: capabilities.rs

   fn load_profile(options: &Capabilities) -> WebDriverResult<Option<Profile>> {
        if let Some(profile_json) = options.get("profile") {
            let profile_base64 = profile_json.as_str().ok_or_else(|| {
                WebDriverError::new(ErrorStatus::InvalidArgument, "Profile is not a string")
            })?;
            let profile_zip = &*base64::decode(profile_base64)?;

            // Create an emtpy profile directory
            let profile = Profile::new()?;
            unzip_buffer(
                profile_zip,
                profile
                    .temp_dir
                    .as_ref()
                    .expect("Profile doesn't have a path")
                    .path(),
            )?;

            Ok(Some(profile))
        } else {
            Ok(None)
        }
    }

source: marionette.rs

    fn start_browser(&mut self, port: u16, options: FirefoxOptions) -> WebDriverResult<()> {
        let binary = options.binary.ok_or_else(|| {
            WebDriverError::new(
                ErrorStatus::SessionNotCreated,
                "Expected browser binary location, but unable to find \
             binary in default location, no \
             'moz:firefoxOptions.binary' capability provided, and \
             no binary flag set on the command line",
            )
        })?;

        let is_custom_profile = options.profile.is_some();

        let mut profile = match options.profile {
            Some(x) => x,
            None => Profile::new()?,
        };

        self.set_prefs(port, &mut profile, is_custom_profile, options.prefs)
            .map_err(|e| {
                WebDriverError::new(
                    ErrorStatus::SessionNotCreated,
                    format!("Failed to set preferences: {}", e),
                )
            })?;

        let mut runner = FirefoxRunner::new(&binary, profile);

        runner.arg("--marionette");
        if self.settings.jsdebugger {
            runner.arg("--jsdebugger");
        }
        if let Some(args) = options.args.as_ref() {
            runner.args(args);
        }

        // https://developer.mozilla.org/docs/Environment_variables_affecting_crash_reporting
        runner
            .env("MOZ_CRASHREPORTER", "1")
            .env("MOZ_CRASHREPORTER_NO_REPORT", "1")
            .env("MOZ_CRASHREPORTER_SHUTDOWN", "1");

        let browser_proc = runner.start().map_err(|e| {
            WebDriverError::new(
                ErrorStatus::SessionNotCreated,
                format!("Failed to start browser {}: {}", binary.display(), e),
            )
        })?;
        self.browser = Some(Browser::Host(browser_proc));

        Ok(())
    }

    pub fn set_prefs(
        &self,
        port: u16,
        profile: &mut Profile,
        custom_profile: bool,
        extra_prefs: Vec<(String, Pref)>,
    ) -> WebDriverResult<()> {
        let prefs = profile.user_prefs().map_err(|_| {
            WebDriverError::new(
                ErrorStatus::UnknownError,
                "Unable to read profile preferences file",
            )
        })?;

        for &(ref name, ref value) in prefs::DEFAULT.iter() {
            if !custom_profile || !prefs.contains_key(name) {
                prefs.insert((*name).to_string(), (*value).clone());
            }
        }

        prefs.insert_slice(&extra_prefs[..]);

        if self.settings.jsdebugger {
            prefs.insert("devtools.browsertoolbox.panel", Pref::new("jsdebugger"));
            prefs.insert("devtools.debugger.remote-enabled", Pref::new(true));
            prefs.insert("devtools.chrome.enabled", Pref::new(true));
            prefs.insert("devtools.debugger.prompt-connection", Pref::new(false));
        }

        prefs.insert("marionette.log.level", logging::max_level().into());
        prefs.insert("marionette.port", Pref::new(port));

        prefs.write().map_err(|e| {
            WebDriverError::new(
                ErrorStatus::UnknownError,
                format!("Unable to write Firefox profile: {}", e),
            )
        })
    }
}

After looking through the gecko source it looks like mozprofile::profile::Profile is coming from FireFox and not geckodriver

It seems that you might have issues with profiles when you migrate to Selenium 4.

ref: https://github.com/SeleniumHQ/selenium/issues/9417

For Selenium 4 we have deprecated the use of profiles as there are other mechanisms that we can do to make the start up faster. Please use the Options class to set preferences that you need and if you need to use an addon use the driver.install_addon("path/to/addon") you can install selenium 4, which is in beta, via pip install selenium --pre

I noted in your code you were writing to user.js, which is a custom file for FireFox. Have you considered creating on these files manually outside of Gecko?

Also have you looked at mozprofile?

    psdbComponent.clickDocumentLink();
    ArrayList<String> tabs2 = new ArrayList<String> (driver.getWindowHandles());
    driver.switchTo().window(tabs2.get(1));
    driver.close();
    driver.switchTo().window(tabs2.get(0));

This code perfectly worked for me. Try it out. You always need to switch your driver to new tab, before you want to do something on new tab.

You need to set the below URL to http://0.0.0.0:9515/wd/hub instead of ****:4723...

WebDriver driver = new RemoteWebDriver(new URL(http://****:4723/wd/hub), capabilities);

Chromedriver's port defaults to 9515, not 4723. You should read the documentation on this. There are other capabilities that need to be set correctly (like BROWSER_NAME)