Selenium with Python Tutorial: How to Get Current URL with Python

How to set the test environment in Selenium using Pytest?

In this section of this article on how to get current URL in Selenium Python, we will learn to set up a test environment.

Installation of Pipenv

Before we start, we will set up a test environment. For this, please follow the steps below:

• We will install Pipenv to manage our dependencies better.Pipenv is a dependency manager for Python projects. If you’re familiar with Node.js’ npm or Ruby’s bundler, it is similar in spirit to those tools. The following command is to install pipenv on macOS. On the official pipenv website, you can see how to install it on other operating systems.

brew install pipenv

• Once the installation is complete, enter the command:

pipenv

The result should look like this:



There are several other alternatives to Pipenv for package management, which can also be used like pyenv, poetry, virtualenv, autoenv, etc. However, adding them is beyond the scope of this blog.

• Creation of Pipfile in an empty directory. This file is essential for using Pipenv. It’s used to track your project’s dependencies if you need to reinstall them.

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true
[packages]
pytest = "*"
selenium = "*"
[requires]
python_version = "*"

Github

The python_version parameter is the version of the base interpreter you specified when creating a new pipenv environment.

The packages section is the place where you can list the packages required for your project.

“*” is for installing the latest stable versions of the packages. At the time of writing this blog on how to get current URL in Selenium Python, the latest versions of Pytest and Selenium are Pytest 7.1.2 and 4.2.2, respectively.

• In your terminal, go to the directory and install the latest stable versions of the Pytest and Selenium packages with the command:

pipenv install


• Download the latest WebDriver for the browser you wish to use. A WebDriver is a remote control interface that enables introspection and control of user agents. It provides a platform- and language-neutral wire protocol for out-of-process programs to instruct the behavior of web browsers remotely. The WebDriver Wire Protocol (aka “WebDriver protocol”) is an open standard that allows the software to interact with a browser as if a human was interacting with the browser.

Here are the download links for the most commonly used browsers.

• Firefox: GeckoDriver
• Chrome: ChromeDriver
• Opera: OperaDriver
• Edge: Microsoft Edge WebDriver

Make sure you have the correct version for your browser, otherwise it won’t work. However, you do not need a WebDriver, in case you are running your test on the cloud Selenium Grid.

The Selenium test configuration in the cloud is managed by a cloud-based Selenium Grid, such as TestMu AI, which will help you run Selenium tests for your web application to ensure cross browser compatibility.

Cloud-based cross browser testing platforms like TestMu AI allow you to perform automation testing on an online browser farm of over 3000+ browsers and operating systems.

Now, let’s add some code to demonstrate how to get current URL in Selenium Python from our Selenium-controlled browser.

How to get current URL in Selenium Python using Pytest?

Now that our project is ready, it is time to add our first test scenario. Here I’ve created:

• “test_ecommerce_playground.py” for scenario 1
• “test_selenium_playground.py” for scenario 2.

This is what the structure of our project should look like:

In Python projects, it is conventional to create a “tests” directory under the project root directory to hold all the test cases. In this module, we simply add functions for our test cases.

We’ll write page object stubs for both pages and then use them to write our test case function. In our project, I’ve created a directory called pages right here.

Notice that this directory is outside of the tests directory.

• We also need it outside because we want this pages directory to be a Python package.
• Python packages are denoted by this __init__.py file (pronounced “dunder init”). It’s just an empty file inside a directory that says, “Hey, this is a Python package, and you can treat it as such, specifically for import statements.”

Let’s add a config.json file to our project. It should be located at the root of our project. The config.json is our configuration file. It allows us to define some settings or preference parameters that will be applied to our project.

It contains a browser, which I have set to “Firefox,” and an implicit timeout. We have hard-coded an implicit timeout of 10 seconds for all interactions. The best way for our tests to read this configuration file will be to use a pytest fixture. You will see this later in our conftest.py file

Scenario 1:

Step 1: Navigate to ‘https://ecommerce-playground.lambdatest.io/‘ Step 2: Search with the keyword “iPhone”. Step 3: Display the current URL of the page in the console. Step 4: Check if the search keyword is in the current URL of the page. Step 5: Save the current URL of the page in a urls.txt file.

Let’s look at the code.

Implementation:

ecommerce_playground.py

from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
class EcommercePlaygroundPage:
   #url
   url = 'https://ecommerce-playground.lambdatest.io/'
   #locators
   search_form = (By.NAME, "search")
   search_button = (By.CSS_SELECTOR, ".type-text")
   # Initializer
   def __init__(self, browser):
       self.browser = browser
 
   # Interaction methods
   def load(self):
       self.browser.get(self.url)
       self.browser.implicitly_wait(30)
 
   def search(self , keyword):
       search_form = self.browser.find_element(*self.search_form)
       search_form.send_keys(keyword)
       search_button = self.browser.find_element(*self.search_button)
       search_button.click()

Code Walkthrough:

from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

The selenium.webdriver module provides all the WebDriver implementations. Currently supported WebDriver implementations are Firefox, Chrome, Microsoft Edge, IE and Remote.

• The By class is used to locate elements within a document.
• The Keys class provides methods through which you can access keys like RETURN, F1, ALT, ENTER, and more. Please read through our earlier blog on handling keyboard actions in Selenium to learn more about it.

test_ecommerce_playground.py

import pytest
from pages.ecommerce_playground import EcommercePlaygroundPage
keyword = "iPhone"
def test_ecommerce_playground(browser):
   ecommerce_page = EcommercePlaygroundPage(browser)
   ecommerce_page.load()
   ecommerce_page.search(keyword)
   get_url = browser.current_url
   title = browser.title
   print("The current url is: "+str(get_url))
   assert "iPhone" in get_url
   with open('urls.txt', 'a') as f:
       f.write(title + " : "+ get_url)
       f.write('
')

Execution Output:

Shown below is the page URL:

urls.txt content is below:

Search - iPhone : https://ecommerce-playground.lambdatest.io/index.php?route=product%2Fsearch&search=iPhone

Scenario 2:

Step1: Navigate to ‘https://www.lambdatest.com/selenium-playground/‘. Step 2: Click Simple Form Demo. Step 3: Display the current URL of the page in the console. Step 4: Save the current URL of the page to a urls.txt file.

Implementation:

FileName – selenium_playground.py

from selenium.webdriver.common.by import By
class SeleniumPlaygroundPage:
   #url
   url = 'https://www.lambdatest.com/selenium-playground/'
   #locators
   simple_form_demo = (By.XPATH, "//a[normalize-space()='Simple Form Demo']")
   # Initializer
   def __init__(self, browser):
       self.browser = browser
   # Interaction methods
   def load(self):
       self.browser.get(self.url)
   def simple_form(self):
       simple_form = self.browser.find_element(*self.simple_form_demo)
       simple_form.click()

test_selenium_playground.py

import pytest
from pages.selenium_playground import SeleniumPlaygroundPage
def test_selenium_playground(browser):
   playground_page = SeleniumPlaygroundPage(browser)
   playground_page.load()
   playground_page.simple_form()
   # Get the current url of the page in a variable
   get_url = browser.current_url
   title = browser.title
   # Display the url in the console
   print("The current url is: "+str(get_url))
   # Save the url in a urls.txt file
   with open('urls.txt', 'a') as f:
       f.write(title + " : "+ get_url)
       f.write('
')

Code Walkthrough:

Automation uses locators to find elements on a page. Selenium locators are simple query strings for finding elements. They will return all elements that match their query.

Selenium WebDriver supports many types of locators — ID, Name, Class Name, CSS Selectors, XPath, Link Text, Partial Link Text, and Tag Name.

Now let’s look at how to get locators for the target items we need for our test scenario.

Here I have used the Inspect Element to store the XPath of the Simple Form Demo link in a variable named simple_form_demo.

simple_form_demo = (By.XPATH, "//a[normalize-space()='Simple Form Demo']")

We will use “find_element“, which is called directly from the WebDriver instance, which we have named browser in our code.

simple_form = self.browser.find_element(*self.simple_form_demo)

To locate the Simple Form Demo element, we’ll need to say browser.find_element and we’ll pass in our simple_form_demo locator.

Now you may be wondering what this asterisk is? Well, the find_element method in Selenium takes two arguments — the locator type and then the query — but simple_form_demo is a tuple.

By adding this here, I can pass my tuple, my locator, into the find_element method. If it’s successful, it will return an object representing the simple_form element on the page.

simple_form.click()

Now, we will use the calls to the element objects returned by the find_element methods. click() allows you to click on an element. Once I have this element, I can click on it to go to the page it redirects to.

# Get the current url of the page in a variable
   get_url = browser.current_url

current_url returns the URL of the page currently loaded in the browser. We used this WebDriver Call to store the Current URL of the page in a variable called get_url.

# Save the url in a urls.txt file
   with open('urls.txt', 'a') as f:
       f.write(title + " : "+ get_url)
       f.write('
')

We then saved the contents of this variable in a urls.txt file.

Execution Output:

After clicking on Simple Form Demo, you are redirected to this page:

Content of urls.txt: