Category: Blog

Ever since the announcement from Google that it will be shipping Headless Chrome, a lot of people have turned to using python to drive Chrome. This may be attributed to the fact that headless browsers have no Graphical User interface (GUI), as well as being navigated using a command line interface or a program. Many, however turn to driving Chrome using python due to the fact that it’s much more fun.

To drive Chrome through Python, however, a lot of people face obstacles like opening a Chrome profile through Python which is required before any other action can be taken. Here, we will discuss the steps to follow on how to open a Chrome profile through Python.

Step by Step Guide to Open Chrome Profile through Python

• Launch your chrome browser, then click open chrome settings where chrome://settings/ is displayed
• Go to People section, select Manage Other people
• Click on Add Person
• Input your name and pick one of numerous icons displayed
• You have to Check the ‘Create a desktop shortcut for this user’ item
• Click the Add button.
• Your new profile is successfully created

This is a sample of how your newly opened profile should look like:

• You will find a desktop icon tagged SeLeNiUm – Chrome
• Through the properties of the SeLeNiUm – Chrome, get the name of the profile directory. e.g. –profile-directory=”Profile 2″. An example of this is shown below:

• Obtain the absolute path of the profile-directory in your computer using the following:

C:\\Users\\Otaku_Wiz\\AppData\\Local\\Google\\Chrome\\User Data\\Profile 2

• Then pass the value of profile-directory through an instance of Options with add_argument() method along with key user-data-dir as shown below:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("user-data-dir=C:\\Users\\AtechM_03\\AppData\\Local\\Google\\Chrome\\User Data\\Profile 2")
driver = webdriver.Chrome(executable_path=r'C:\path\to\chromedriver.exe', chrome_options=options)
driver.get("https://www.google.co.in")

• Launch your Test and you will notice your Chrome is initiated with the Chrome profile as Selenium

There are several situations where users run into problems concerning the inability to click an element through the selenium WebDriver “click” command but can easily execute it with a JavaScript click. An example of this scenario in both Python and WebDriver JavaScript is provided below:

In Python,

element = driver.find_element_by_id("myid")
driver.execute_script("arguments[0].click();", element)
While in WebDriver JavaScript,
var elm = $("#myid");
browser.executeScript("arguments[0].click();", elm.getWebElement());

This issue has raised questions concerning the difference between the JavaScript click and the WebDriver click. Many are also eager to know why it is possible to Click through JavaScript when it seems not to work in WebDriver click and thus brings thoughts as to the possibility of a risk attached.

JavaScript click () vs WebDriver click ()

For the WebDriver, when the click works, the simulation of real user experience on a browser is attempted. For clarification, let’s assume an element A represents a button that displays ‘Click me’, and another element B is categorized as a div element that is characteristically transparent with its dimensions. After you instruct the WebDriver to click A, the instruction will be transmitted, and the click will be simulated, so that element B is the first recipient of the click. This happens because element B covers element A. That is, any user who tries to click on element A would have to first go through element B. Element A may receive the click, or not, depending on the way element B handles the instruction. As the case may be, the actions of the WebDriver at this time are identical to a situation where a real user attempts to click on element A.

In the case of JavaScript click () to Click element A, it does not duplicate precisely what happens when a real user attempts to click element A like WebDriver does. Instead, JavaScript transmits the click instructions directly to element A without any interference by element B.

ElementNotInteractableException is one of the few notable exceptions encountered in the Selenium WebDriver. This W3C exception is thrown to outline how, regardless of the presence of an element in the HTML DOM, it still can’t be interacted with. This is evident in the inability to click or send keys, functions which make running the Selenium WebDriver possible. There are many root causes which may be attached to this problem; the prominent ones are element invisibility or non-display and hidden element behind another. Through this article, we will outline the few steps you can take to rectify this issue.

Temporary Overlay of other WebElement over the WebElement of our interest

When this problem has been identified as the root cause, the most effective way to resolve this is to execute ExplicitWait by combining WebDriverWait and ExpectedCondition as invisibilityOfElementLocated. A sample of this is analyzed below:

WebDriverWait wait2 = new WebDriverWait(driver, 10);
wait2.until(ExpectedConditions.invisibilityOfElementLocated(By.xpath("xpath_of_element_to_be_invisible")));
driver.findElement(By.xpath("xpath_element_to_be_clicked")).click();

Another way to go about solving this problem is by approaching it on a more granular level by using ExpectedCondition as elementToBeClickable as opposed to using ExpectedCondition as invisibilityOfElementLocated. This is analyzed below:

WebDriverWait wait1 = new WebDriverWait(driver, 10);
WebElement element1 = wait1.until(ExpectedConditions.elementToBeClickable(By.xpath("xpath_of_element_to_be_clicked")));
element1.click();

Permanent Overlay of other WebElement over the WebElement of our interest

The best solution for this type of problem is by casting the WebDriver instance as if the overlay is a permanent one. In this case, we have to cast the WebDriver instance as JavascriptExecutor followed by a click operation. This step is analyzed below:

WebElement ele = driver.findElement(By.xpath("element_xpath"));
JavascriptExecutor executor = (JavascriptExecutor)driver;
executor.executeScript("arguments[0].click();", ele);

Other general ways of solving the ElementNotInteractableException include:

• Waiting until an element is visible/clickable

WebDriverWait wait = new WebDriverWait(driver, timeout);
wait.until(ExpectedConditions.visibilityof(element));
wait.until(ExpectedConditions.elementTobBeClickable(element));

• Scroll until the element is within the display

Actions action = new Actions(driver):
action.moveToElement(element);

• Utilizing JS Executor to interact with the DOM

JavascriptExecutor javascript = (JavascriptExecutor) driver;
javascript.executeScript("var element = document.querySelector('locator');element.value = 'whatever';")

When looking out for ways to deal with #document under iframe, it is essential to consider iframe as a build that is enclosed within another document or data file into an HTML to display the embedded data or code in a sub-window within the current window of the browser. It is, therefore, impossible to treat one document as independent of another.

The Ultimate Way Out

An inline frame element is usually found in this form:

<iframe src="URL" more attributes>
alternative content for browsers which do not support iframe
</iframe>
The documents which are referred to by the URL in a particular subwindow

The documents which are made according to the URL in a sub-window are displayed with either vertical/horizontal scroll bars in browsers that support inline frame. These types of browsers display regardless of the contents of the inline frame element, while browsers that don’t support the inline frame take the opposite action by processing the contents of the iframe element with the assumption that the <iframe…> and </iframe> tags were absent. This leads to the conclusion that the contents of the iframe elements are essential regardless of the negligence by a few browsers.

Using JavaScript to Communicate iframe

JavaScript can be utilized in communicating with the iframe and the documents within it. The first of the few steps is to acquire the references to the iframe, the properties, and finally, the contents within it. To acquire the references to an iframe, you should use the getElementById. The references acquired can then be used to edit the properties found on the iframe.

// reference to iframe with id 'ifrm'
var ifrm = document.getElementById('ifrm');
ifrm.style.width = '400px'; // set width
ifrm.src = 'newpage.html'; // set src to new url

Other properties entailed in the iframe element include both the contentWindow and contentDocument properties. References to the iframe documents window and objects can be acquired from these properties using JavaScript. This step is analyzed below:

// using reference to iframe (ifrm) obtained above
var win =  ifrm.contentWindow; // reference to iframe's window
// reference to document in iframe
var doc = ifrm.contentDocument? ifrm.contentDocument:
ifrm.contentWindow.document;
// reference to form named 'demoForm' in iframe
var form = doc.getElementById('demoForm');

Immediately the references to the window and document have been acquired; it is possible to gain access to any object or property bound within the iframe document.