# Selenium - Notes - 2
## 0. Modularize functions and everything that can be modularized
For example, need to check if a class of an element contains `disabled` before clicking (such as the next and previous icons). Thus, create another function to check if `disabled` is not in WebElement, then click the WebElement.
## 1. Check if an element class contains `disabled`
Or check other attributes of the element that indicate the element's displayed or interactable status.
Get the element first, get the class attribute of the element, and check if it contains the keyword `disabled`. Interact with the element if it does not contain `disabled`. (or remove the `disabled` attribute before interacting with the element)
For example,
```
WebElement lastPageLink = new WebDriverWait(driver, elementTimeout).until(ExpectedConditions.visibilityOfElementLocated(lastPageLinkBy));
if (!(lastPageLink.getAttribute("class").contains("disabled"))) {
lastPageLink.click();
}
```
## 2. Interact with Pagination
An example of what pagination looks like:
https://community.jaspersoft.com/blog/java-selenium-how-navigate-through-web-data-table-using-pagination-buttons-and-verify-displayed
### Check elements loading completed
Check the texts of the pagination information elements should display the correct information.
For example, from 101 to 111 in total 2001
### Check whether page navigation is available or not
If the current page is at the end of the pagination, the next page navigation element should contain `disabled`, and should not be clickable.
### Wait for the page to be ready after the navigation
Wait until the target element with the correct index is displayed or exists.
### Navigate to the next page or the previous page
Wait until the currently selected element (focused page) is different from the previously selected element.
For example, the selected index of the next page is `current page +1` (the selected index of the previous page is `current page -1`) :
```
private By currentFocusBy = By.cssSelector("span[class='k-state-selected']");
public Pagination clickNextPage() {
// Check if element contains disable class attribute
WebElement nextLink = waitVisible(nextLinkBy));
if (!(nextLink.getAttribute("class").contains("disabled"))) {
// Keep the index from the text in currently selected element
final String preIndex = waitVisible(currentFocusBy).getText();
final String afterIndex = Integer.toString((Integer.parseInt(preIndex) + 1));
// Wait until the next page icon exists and click
waitAndClick(nextLinkBy);
// Wait until the index of current selected is the previous +1
final By currentBy = By.xpath("//span[@class='k-state-selected' and text()='" + afterIndex + "']");
waitVisible(currentBy);
}
return this;
}
```
### Navigate to the first or the last page
* The first page
* Wait until the index of the currently selected element is 1
* The last page
* Wait until the index of the currently selected element is `Math.ceil((number of total rows) / (number of rows per page))`
Get total count from pagination information element (the information of current display and count of total items might need to be parsed from element text).
Method to get the information string from the information element:
```
public final String getPaginationInfoText() {
return waitVisible(paginationInfoBy).getText();
}
```
Method to parse numbers in information string:
```
public final Map<String, Integer> getNumbersFromItemsInfoText() {
Map<String, Integer> itemCountsMap = new HashMap<String, Integer>();
String[] keys = new String[] { "From", "To", "Total" };
int keyIndex = 0;
// Parse all numbers from the information string text
String[] dataLs = getPaginationInfoText().split(" ");
for (String data : dataLs) {
if (NumberUtils.isCreatable(data)) {
itemCountsMap.put(keys[keyIndex], Integer.parseInt(data));
keyIndex += 1;
}
}
return dataMap;
}
```
Get current rows per page from the selected item in the dropdown list, and wait until the element is visible:
```
public final int getCurrentDisplayedPerPage() {
return Integer.parseInt(waitVisible(currentDisplayedBy).getText());
}
```
Calculate the page index of the last page:
```
private final int getLastPageIndex(){
final Map<String, Integer> infoMap = getNumbersFromItemsInfoText();
final int displayedPerPage = getCurrentDisplayedPerPage();
final int lastPageIndex = Math.round((float) infoMap.get("Total") / displayedPerPage);
return lastPageIndex;
}
```
Click the `lastPageLink` and verify the currently selected element is the last page:
```
public Pagination clickLastPage() {
// Check contain disable
WebElement lastPageLink = waitVisible(lastPageLinkBy);
if (!(lastPageLink.getAttribute("class").contains("disabled"))) {
// Click the last page element
lastPageLink.click();
// Wait for the current selected element to be the last page element
final By currentBy = By.xpath("//span[@class='k-state-selected' and text()='" + getLastPageIndex() + "']");
waitVisible(currentBy);
}
return this;
}
```
## 3. Need to clear input fields before keying in new data
Common way:
```
inputElement.clear();
```
When the previous one does not work, try to use send keyboard key to clear the text in the input fields:
```
inputElement.sendKeys(Keys.chord(Keys.CONTROL,"a", Keys.DELETE));
```
For example:
```
WebElement inputElement = new WebDriverWait(driver, elementTimeout)
.until(ExpectedConditions.elementToBeClickable(by));
inputElement.sendKeys(Keys.chord(Keys.CONTROL,"a", Keys.DELETE));
inputElement.sendKeys(text);
```
## 4. Access data in **tb** in a table element
Loop the current page table rows by using indexes to access data in each row in the table:
```
public List<String> getDataListFromTableRow(final int numberOfRows) {
List<String> dataLs = new ArrayList<String>();
String text = "";
for (int i = 0; i < numberOfRows; i++) {
text = waitVisible(By.xpath("//div[@id=\"dataGrid\"]/div[3]/table/tbody/tr[" + (i + 1) + "]/td[1]"))
.getText();
dataLs.add(text);
}
return dataLs;
}
```
When landing on a new page of pagination, get the latest row counts of the current page.
An example of getting all data from the current page, and navigating to the next page:
```
final int totalPageCount = pagination.getTotalPageCount();
int rowCount = 0;
for (int pageIndex = 0; pageIndex < totalPageCount; pageIndex++) {
rowCount = pagination.getPageRowCount();
nameLs = Stream.concat(nameLs.stream(), unitAssetsPage.getAssetIdContentsText().stream()) .collect(Collectors.toList());
}
```
Methods that are used in the previous block:
```
protected List<WebElement> getVisibleElements(final By by) {
return new WebDriverWait(driver, elementTimeout).until(ExpectedConditions.visibilityOfAllElementsLocatedBy(by));
}
private By tableRow = By.xpath("//tr[@class='k-master-row' or @class='k-alt k-master-row']");
public final int getPageRowCount() {
return getVisibleElements(tableRow).size();
}
```
## 5. Use proper data structures to load data from page elements
It is important to choose the proper data structure/ interface/ class to load data from elements based on CRUD needs.
For example, using 2D lists to store the table elements data.
```
Map<String, List<String>>
```
## 6. Locate row elements of a table by class name of the row elements
Need to be aware of the class name of **odd** and **even** rows might be different.
## 7. Load data from tags elements
Need to understand how tags are designed.
For example, a tag can be a composition of **multiple** texts or only allow **single** text. (I think a tag should only have one text, it is a bad design to contain multiple texts in one tag)
One text in one tag
Multiple texts in one tag
## 8. Handling dynamic elements
Check whether the target element exists or not beforehand.
## 9. Handling Selenium Exception using `try catch`
Refer to: https://www.softwaretestinghelp.com/exception-handling-framework-selenium-tutorial-19/
To return `null` or display error messages, use `try catch` to get certain exceptions and deal with them.
Need to use the correct exceptions to catch the correct exception when under certain conditions.
### Example of the usage
#### Do something when cannot find the element
Find element use `org.openqa.selenium.By` without `org.openqa.selenium.support.ui.WebDriverWait`, and the corresponding Exception:
```
try {
WebElement webElement = driver.findElement(by);
}
catch(org.openqa.selenium.NoSuchElementException ex) {
// do something
}
```
#### Do something when timeout of waiting for the element
Find element use `org.openqa.selenium.support.ui.WebDriverWait`, and the corresponding Exception:
```
try {
WebElement webElement = new WebDriverWait(driver, 10).until(ExpectedConditions.visibilityOfElementLocated(by));
}
catch(org.openqa.selenium.TimeoutException ex) {
// do something
}
```
#### Test clean-up e even though exceptions happen
Add finally after `try catch` and call close browser no matter test pass or failed to clean up the tests
```
def test_search():
try:
driver = BrowserFactory.get_chrome()
driver.get("https://blog.testproject.io/")
driver.maximize_window()
home = HomePage(driver)
home.keyin_search("selenium")
except Exception:
assert False
finally:
driver.close()
```
##### Common Exceptions:
* org.openqa.selenium.NoSuchElementException
* org.openqa.selenium.NoSuchWindowException
* org.openqa.selenium.NoSuchFrameException
* org.openqa.selenium.NoAlertPresentException
* org.openqa.selenium.InvalidSelectorException
* org.openqa.selenium.ElementNotVisibleException
* org.openqa.selenium.ElementNotSelectableException
* org.openqa.selenium.TimeoutException
* org.openqa.selenium.NoSuchSessionException
* org.openqa.selenium.StaleElementReferenceException
## 10. Handle **Element not interactable** error
When using `presence_of_element_located()` to locate and interact with the element, sometimes get this error.
### Solution
Can use `element_to_be_clickable()` before clicking, to make sure the element can be interacted.
```
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
element = WebDriverWait(self.driver, self.waittime).until(EC.element_to_be_clickable(self.elementBy))
element.click()
```
###### tags: `selenium` `java` `test automation` `software test`
Sign in with Wallet
Connect another wallet