Selenium Automation Testing on Internet Explorer (IE) & Edge
Tags: selenium, testing
Published: 2019-08-21 08:16:06

---
title: Selenium Automation Testing on Internet Explorer (IE) & Edge
published: true
description: We look into Selenium automation testing for IE and Edge browsers, most common challenges with Selenium &amp; IE, along with different ways to test IE on macOS.
tags: selenium, testing
canonical_url: https://www.lambdatest.com/blog/selenium-automation-testing-on-internet-explorer-ie-edge/
cover_image: https://www.lambdatest.com/blog/wp-content/uploads/2019/08/Selenium.jpg
---

Design and Usability are two important factors when you are building a consumer web product/web application. You might need to step into the shoes of the customers in order to tackle different usability problems. However, you may have to fill in a lot of shoes considering the fact that not all your customers would be using the same browsers as you. [Cross browser testing](https://www.lambdatest.com/?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu) becomes a pivotal part of every test cycle. As a tester or developer, you might be using the macOS for product development but you need to take care of scenarios where customers use deprecated browsers like Internet Explorer.

IE has been a headache for web development ever since modern browsers such as Chrome, Safari, Mozilla Firefox, and many more stepped into the picture. Delivering a slow response time, and lack of features has led the majority of IE users to switch for some other browsers. So if you have developed a website on Chrome, then, to have it tested on IE is going to be a major concern. As long as you are a windows user it may seem feasible, but what would a macOS user do?

One common question that developers & testers often think about is how to test IE on macOS? And even if you do find a way to test IE on mac, is there a way to incorporate automation testing for testing IE on mac?

This article is my attempt to help you perform automation testing with Selenium for testing IE on macOS, we will also be looking into Edge browser. But before we get started with automation testing, let us understand whether we really need to test IE? As many of us assume that testing on IE is a waste of time because people hardly use it, while some of us think otherwise. We will clear that dilemma as we go through.

## Should You Consider Microsoft Internet Explorer (IE) For Cross Browser Testing?

IE might not be the most preferred browser from a web-development & design point of view but there is still a significant percentage of users that makes use of IE. As per [Desktop Browser Market Share Worldwide](http://gs.statcounter.com/browser-market-share/desktop/worldwide/#monthly-201806-201906), IE as of July 2019 holds a 5% market share in the web browser market which is a good number considering the overall number of internet users worldwide.

![browser stats](https://cdn.lambdatest.com/blog/wp-content/uploads/2019/08/pasted-image-0-1.png)

There are a significant number of end-users, as well as enterprises that use Microsoft’s Internet Explorer for browsing and performing other tasks on the web. In fact, there are many enterprises that push their testers to [perform cross browser testing](https://www.lambdatest.com/blog/performing-cross-browser-testing-with-lambdatest/?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu) only on Internet Explorer(IE) for internal tasks. Hence, you might end up in situations where there are multiple ‘compatible’ browsers installed on your Mac machine but you need to test your product against Internet Explorer or Microsoft Edge. Browser compatibility testing is a core component in testing features of any web product/web application. Overlooking the same can lead to serious usability problems on the customer front.

You may argue about the reason for considering an outdated browser like IE for cross browser testing. To some extent, the argument is correct since the official support for IE was discontinued in the year 2015. There are no official updates or support for IE since that time. Though Microsoft Security Chief – Chris Jackson urged users to stop using IE three years back, there is still a significant user base that is still using IE as the default browser. In a blog titled [The perils of using Internet Explorer as your default browser](https://techcommunity.microsoft.com/t5/Windows-IT-Pro-Blog/The-perils-of-using-Internet-Explorer-as-your-default-browser/ba-p/331732), Chris Jackson stated

> Internet Explorer is a compatibility solution. We’re not supporting new web standards for it and, while many sites work fine, developers by and large just aren’t testing for Internet Explorer these days. They’re testing on modern browsers. So, if we continued our previous approach, you would end up in a scenario where, by optimizing for the things you have, you end up not being able to use new apps as they come out. As new apps are coming out with greater frequency, what we want to help you do is avoid having to miss out on a progressively larger portion of the web!

***If you are preparing for a Playwright automation interview, this list of*** [***Playwright interview questions***](https://www.lambdatest.com/learning-hub/playwright-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***can help you get a list of the most asked questions with detailed answers.***

So should you consider IE for browser compatibility testing?

Yes, you should. Although IE is being redundant slowly, it still holds a significant 5% of the overall browser market share for Desktops. Even if you are using macOS, you should make sure that you test IE on the mac so that there are no issues when users access your website/web application. Wondering on how you can test IE on mac?

## Cross Browser Testing With IE On macOS Device

Mac does not support Internet Explorer. However, if you are a developer using Mac, this excuse may not fly with your end clients. And that goes with your Selenium automation tests as well. You would have to find a way to run your test scripts on Internet Explorer browsers as well. There are a couple of ways in which you can test IE on macOS systems:

### 1. [VM Virtual Box](https://www.virtualbox.org/)

If you are a developer, there is a high probability where you would have made use of the Oracle VM Virtual Box. It lets you install a variety of operating systems in a virtual environment. In order to test IE on Mac, you need to install VM Virtual Box on your device. Once installed, the extension pack and installed the .dmg image on your macOS, can help you perform cross browser testing using IE on Mac.

For installation and other relevant information about Oracle VM Virtual Box, we recommend you to check this link. You might want to have a look at the relevant VM commands that can be used along with IE.

### 2. [Cross Browser Testing Cloud](https://www.lambdatest.com/)

This is one of the ideal ways in which you can achieve the task of [browser compatibility testing](https://www.lambdatest.com/feature?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu); not only on IE but a host of other browsers like Chrome, Firefox, Safari, Opera, etc. There are cross browser testing platforms like LambdaTest where you can test the nitty-gritty of your website/web application against 2000+ browsers on a variety of operating systems & devices. You can find the complete [list of browsers](https://www.lambdatest.com/list-of-browsers?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu) available on the LambdaTest platform.

Porting your existing Selenium automation testing implementation that makes use of local Selenium Grid to remote Selenium Grid hosted on LambdaTest cloud servers is a simple task. You can test on IE, even if you are a macOS user without any local installation. All you need to do is select the configurations on which you need to test, declare them in your Desired Capabilities and have them executed on VMs(Virtual Machines) hosted on LambdaTest cloud servers. This requires zero setups or downtime from your end, and you can leave the maintenance part on us. So you focus on doing what you do best, coming up with awesome test cases, while we take care of providing you with all the testing environments you need as per your test script.

Another upside of using LambdaTest Selenium Grid is that you can perform Selenium automation testing with every programming languages like Python, C#, Java, etc. that offers compatibility with Selenium through bindings.

### 3. [WineBottler](http://winebottler.kronenberg.org/)

WineBottler for Mac is very much similar to Wine on Linux as both of them are used for the same task i.e. running Windows on host operating system like Mac/Linux. WineBottler 1.8.6 (stable version) is currently available for macOS:

- High Sierra 
- Sierra
- El Capitan
- Yosemite
- Mavericks
- Mountain Lion
- Lion
- Snow Leopard

You would need to download and install the WineBottler application on your Mac machine/device. Once installed, you can start using IE that is available by default with the installation. The only downside about such an approach is that you need to again install your entire software development environment on the virtual Windows OS to use Selenium automation testing framework for automated cross browser testing.

### 4. Installation of Windows on Mac

In case you are keen to have a dual-boot kind of setup on your Mac machine; you should opt for installing a Windows operating system on a Mac.

Before going ahead with this option, it is important to check whether the version of macOS which you are using supports Windows or not. In case there is support, you need to follow the necessary steps for [installing Windows on Mac](https://support.apple.com/en-al/HT201468). Once the installation is complete, you need to restart your machine after which you would be prompted to select your preferred OS (Mac/Windows) to boot the system/device. Though this is a local Windows installation, you still need to go through all the necessary steps to perform Selenium Automation Testing with Python or any other programming language.

***Here’s Top 30+*** [***WebdriverIO Interview Questions***](https://www.lambdatest.com/learning-hub/webdriverio-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***and Answers that will help you boost your confidence in an Interview.***

### 5. User-agent on Safari Browser

Though Safari is the default browser on macOS; you can leverage the User Agent option on Safari to test IE on Mac without any installation/virtualization. All you need to do is change the user-agent to Internet Explorer by clicking on one of the Internet Explorer options. The user-agent option is available in the **Develop -\> User Agent** menu item.

You also have the option to choose **Google Chrome – Windows or Firefox – Windows** if you plan to perform cross browser testing on browsers apart from IE/Safari.

### 6. Virtualization

Using virtualization, you can run Windows on your Mac machine. There can be multiple Virtual Machines (VMs) along with Windows VM so that you can test your website/web application on different operating systems at the same time. You would require a powerful machine to accomplish this task.

Different options for Virtualization on macOS are Parallels Desktop, VMWare Fusion, VirtualBox, Apple Boot Camp, etc.


### 7. Remote IE

Remote IE is a tool launched by Microsoft. Using Remote IE, you can perform test your product against IE which is installed on a Windows Server running on Microsoft Azure Cloud. Since you will be using a virtual machine on which IE is installed, you do not require any local installation to test IE on Mac. It runs just like any other native application.

The entire process of connecting to the Cloud and accessing IE is simple. Microsoft has built Microsoft Remote Desktop application for macOS X which can be downloaded from the Mac Application Store from here.

These were different ways to test IE on macOS. Now, let’s get into action and perform automated cross browser testing with Selenium for internet explorer. We will also look into different challenges that one may face while Selenium automation testing on IE.

## Cross Browser Testing Using Selenium With Internet Explorer (IE)

It is important to understand that many advanced features might not work on IE. IE is comparatively slow when compared to other latest web browsers and this could also impact the overall performance of the web page when it is loaded on IE. It is likely that you might encounter a number of NoSuchElementFound exception & synchronization issues when you are using JavaScript test suites with the 64-bit version. Along with those issues, you might also come across problems with mouse events, hover events, keyboard events, CSS selectors, etc. I am going to talk

### Challenges When Automation Testing With Selenium & Internet Explorer (IE)

**1. WebDriverWait for handling synchronization issues**

Synchronization issues can be handled by making sure that sufficient time is given to the web elements to load before an action is performed on them. You can make use of Implicit Wait or Explicit Wait to achieve synchronization. In Implicit Wait, the webdriver will wait even if the element is loaded to avoid throwing up the No Such Element exception. This might impact the performance of the test cases.

If you wish to apply to wait on particular web elements, then Explicit Wait will help you do so. You wait on a particular condition and once that condition is satisfied, it exits from the loop.

**2. CSS Selectors**

As per Caniuse, IE7 & IE8 only have partial support for CSS3 locators. The CSS3 locators that are supported on these versions are General siblings (element1 ~ element2) and Attribute selectors ([attr^=val], [attr$=val], and [attr\*=val]). However, all the CSS3 selectors are supported on more popular versions of IE i.e. IE9~ IE11 ([Source](https://caniuse.com/#feat=css-sel3))

**3. Handling of Native events, Mouse events, etc.**

The IE WebDriver makes use of native Windows events to perform HID operations i.e. operations using the keyboard, mouse, or other HID device. Developers have faced a number of issues when using HID devices on IE for Selenium automation testing. The only workaround is to re-test using JavaScript.

**4. Performance problems with SendKeys**

The Selenium framework makes use of the Selenium WebDriver for interacting with the web elements on the web page. Depending on the architecture of your machine (32-bit, 64-bit), you need to download IEDriverServer.exe which will take commands from the Selenium script and interact with the browser. IEDriverServer.exe for 32-bit architecture and 64-bit architecture can be downloaded from [here](https://goo.gl/9Cqa4q) & [here](https://goo.gl/AtHQuv) respectively.

Performance issues have been reported by developers where typing is very slow in the text field on IE. To overcome this problem, you need to make use of Selenium WebDriver for 32-bit IE even though your machine architecture is 64-bit. Once this is done, the SendKeys() performance on IE would be on par with the performance on popular browsers like Chrome, Firefox, etc.

***Prepare to ace your Jest interviews with our thorough set of*** [***Jest interview questions***](https://www.lambdatest.com/learning-hub/jest-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***and solutions that will enable you to prove your command of the Jest testing framework.***

### Automation Testing With Selenium & Internet Explorer

So far we have looked at the importance of considering IE for browser compatibility testing and the challenges you would face when testing on IE. We also looked at options on how you can test with IE on Mac.

Now, let’s have a look at how you can perform automation testing with Selenium & IE; for demonstration, we are making use of a Windows 10 machine which has pre-installed Internet Explorer browser. In order to get started, you should have Python & Selenium framework installed on your machine. You can download Python installation files for Windows from [here](https://www.python.org/downloads/windows/). To install Selenium, you should execute pip install selenium on your terminal. For implementation, we make use of PyCharm IDE (Community Edition) which can be downloaded from [here](https://www.jetbrains.com/pycharm/download/).

With the basic setup ready for Selenium automation testing, the next step is to download IE WebDriver i.e. IEDriverServer executable on your development machine. The download locations are below:

![Capture35.PNG](https://ucarecdn.com/74bfe8be-3e01-42ec-b538-c1dd3fd7a4b7/)

If you face any issues with 64-bit IE during the course of development & testing, replace WebDriver 64-bit IE with WebDriver for 32-bit IE as discussed in the earlier section. Add the path (where IEDriverServer.exe is present) to the environment variable PATH using set PATH=%PATH%;.

Let us have a look at a simple example that demonstrates Selenium automation testing with IE where the task is to perform a search on Duckduckgo.

FileName – test\_1\_duckduckgo\_search.py

```
import unittest
from selenium import webdriver
import time
from time import sleep

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

class SeachTest(unittest.TestCase):
    def setUp(self):
        # Creation of IE WebDriver instance
        self.driver = webdriver.Ie(executable_path=r'location_of_IEDriverServer.exe')

    def test_Search(self):
        driver = self.driver
        driver.maximize_window()
        driver.get("https://duckduckgo.com/")
        elem = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.NAME, "q")))
        elem.send_keys("Lambdatest")
        elem.submit()

        sleep(10)

    def tearDown(self):
        # Close the browser.
        self.driver.close()

if __name__ == '__main__':
    unittest.main()
```

The example makes use of the unittest framework in Python. If you are not aware of unittest, we recommend you to read our blog on [parallel testing with Selenium & Python using unittest](https://www.lambdatest.com/blog/parallel-testing-in-selenium-webdriver-with-python-using-unittest/?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu).

The prerequisite steps for initialization & setup are done in the setup() method and clean-up steps are done in the tearDown() method. A local WebDriver is used to invoke an instance of IE.

```
def setUp(self):
        # Creation of IE WebDriver instance
        self.driver = webdriver.Ie(executable_path=r'location_of_IEDriverServer.exe') 
```


A WebDriverWait() of 20 seconds is used to ensure that the loading of the search box on Duckduckgo is complete. The execution was done by invoking python \<file\_name.py\> from the terminal. Shown below are some of the options that you can set while configuring the IE browser for Selenium Automation Testing.

![webdriver](https://cdn.lambdatest.com/blog/wp-content/uploads/2019/08/image1.png)

Since this was the very first cross browser testing with Selenium & IE, there were a couple of issues that we encountered during the process:

**NoSuchWindowException –** The exception was raised due to incorrect Protected Mode Settings in IE. As per the [official documentation of InternetExplorer Driver](https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver), the Protected Mode settings for each zone should be the same i.e. High/Medium/Medium-High.

![NoSuchWindowException](https://cdn.lambdatest.com/blog/wp-content/uploads/2019/08/unnamed.png)

To change the settings, please go to Tools -\> Internet Options -\> Security option on the IE browser. Set the same Protected Mode Settings for each zone i.e. Internet, Local Intranet, Trusted Sites, and Restricted Sites.

![NoSuchWindowException](https://cdn.lambdatest.com/blog/wp-content/uploads/2019/08/unnamed-1.png)

Also, disable Enhanced Protected Mode for each zone. Restart IE to apply the settings and now you would not encounter this issue.

**Lag in event handling –** The connection between the WebDriver i.e. IEDriverServer.exe and browser under test i.e. IE might get lost during the process of testing. This can happen when you are waiting for a dynamic web element to be loaded on the page. You need to perform two important setup changes mentioned below

- **Creation of iexplore.exe key in registry (only for IE 11) –** In case you are using IE 11, you should create a new entry in the registry.  

![Capture34.PNG](https://ucarecdn.com/24036f1d-c776-4cec-8db7-eb7141d42bcf/)

Subkey FEATURE\_BFCACHE may or may not be present. If it is not present, you should first create the subkey; create a new entry of DWORD type named iexplore.exe, and assign value 0 to it.

![Dword](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/unnamed-2.png)

- **Browser Zoom Level –** In case you have changed the browser zoom level, please set it to 100% so that native mouse events can be set to the correct coordinates.
- **32-bit IEDriverServer.exe on the 64-bit machine –** We had earlier mentioned about the performance issues with 64-bit IE WebDriver and we could witness the lag when they search for LambdaTest was performed on Duckduckgo. We replaced the 64-bit IEDriverServer.exe with 32-bit IEDriverServer.exe and the performance was perfectly fine!

We look at another example where interaction with the web locators is done to perform relevant actions. You can make use of the Inspect Element on IE or any other browser installed on your machine to get details about the web locators i.e. XPath, CSS Selector, Name, Link Text, ID, etc. We have made use of NAME and XPath locators to perform actions on those web elements.

```
from selenium import webdriver
from time import sleep
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait

# Internet Explorer
driver = webdriver.Ie(executable_path=r'location_of_IEDriverServer.exe')
driver.maximize_window()
driver.get("https://www.lambdatest.com")

try:
    myElem_1 = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'home-btn')))
    print("Home Button click under progress")
    myElem_1.click()

    myElem_2 = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.XPATH, "/html/body/div[1]/section/div/div[2]/div/form/div[3]/p/a")))
    print("Login button click under progress")
    myElem_2.click()
    sleep(10)
except TimeoutException:
    print("No element found")

sleep(10)

driver.close()
```


As seen in the example above, a wait of 10 seconds is performed for each web element before a TimeOutException is raised if the element is not found.

Now, that we know how to test IE on macOS and incorporate Selenium automation testing on IE. It is only natural to dwell on to Microsoft Edge browser! What should we make of Microsoft Edge considering the state of IE in 2019? Should Microsoft Edge browser be a part of your cross browser testing script? Let’s find out.

***Get ready for your Mocha interview with our expert-curated list of*** [***Mocha interview questions***](https://www.lambdatest.com/learning-hub/mocha-interview-questions?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***tips. Impress your potential employer and land your dream job.***

### Should I Include Microsoft Edge In My Browser Compatibility Testing?

Microsoft Edge is the default browser in Windows 10. This statement itself is enough to prove that web developers & testers should not ignore Microsoft Edge browser while planning for browser compatibility testing. Windows 10 has close to 50% market share which means that Microsoft Edge is installed by default on those machines ([Source](https://www.computerworld.com/article/3199373/windows-by-the-numbers-upgraders-press-pause.html)).

Though users may install other popular browsers like Chrome, Firefox, etc. for browsing or another web-related work; the relevance of Microsoft Edge as far as browser compatibility testing is concerned cannot be ruled out. As seen in the Desktop Browser Market Share Worldwide graphic, the market share of Microsoft Edge browser us around 4.61% and this percentage would slowly rise with more penetration of Windows 10.

![stackcounter](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/stackcounter.png)

So, Microsoft Edge is just as important for you to test for browser compatibility as IE. In coming years, the market share of Microsoft Edge browser is expected to rise. So, should Microsoft Edge be a part of your browser compatibility testing script?

Yes, absolutely. But how can a user who is operating on macOS test on Edge browser? Let’s find out.

## How To Test Microsoft Edge on macOS?

Microsoft Edge has been officially made available for macOS users. It is not a final version though and is still in the testing phase. Microsoft updated the same in their [Windows Blog](https://blogs.windows.com/msedgedev/2019/05/20/microsoft-edge-macos-canary-preview/) on 21 May 2019:

> Microsoft Edge for macOS will offer the same new browsing experience that we’re previewing on Windows, with user experience optimizations to make it feel at home on a Mac. We are tailoring the overall look and feel to match what macOS users expect from apps on this platform.

You can download Microsoft Edge preview builds for macOS from [Microsoft Edge Insider Channels](https://www.microsoftedgeinsider.com/en-us/download?platform=macos).

![microsoft edge insider](https://cdn.lambdatest.com/blog/wp-content/uploads/2019/08/microsoft-edge-insider.png)

Other than that, if you own a macOS device & wish to see your website on a Windows operating system through an Edge browser then you can always turn to cloud-based cross browser testing tool such as LambdaTest.

LambdaTest offers you the convenience to test your website on various Microsoft Edge versions through a Windows OS on the cloud. You can test on Edge versions 15, 16, 17, 18, and Edge Insider.

***Ace your QA interviews with our comprehensive guide on 60+*** [***SpecFlow Interview Questions***](https://www.lambdatest.com/learning-hub/specflow-interview-questions?utm_source=devto&utm_devto=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***and Answers. Boost your BDD knowledge and showcase your SpecFlow expertise.***

## Automation Testing With Selenium & Microsoft Edge

To get started with Selenium automation testing using Microsoft Edge, you need to install Selenium WebDriver for Edge from[here](https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/). You should select the appropriate WebDriver since there are options for Microsoft Edge (Chromium) and Microsoft Edge (EdgeHTML). Microsoft Edge (Chromium) or Microsoft Edge (Dev version) can be downloaded from [here](https://www.microsoftedgeinsider.com/en-us/). Since we are using Windows 10 machine for development & testing, we already have Microsoft Edge pre-installed in it. In our case, we need to select the Selenium WebDriver for Microsoft Edge (EdgeHTML).

Before downloading the WebDriver for Edge, you should check the OS build from System Settings. In our case, the OS build version is 17134.885 hence, we downloaded the WebDriver for Microsoft Edge with the Release 17134.

![automation testing](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/image8.png)

You need to copy the download WebDriver i.e. MicrosoftWebDriver.exe to a particular location in the machine and append the path to the $PATH environment variable by executing the command set PATH=%PATH%;.

The Duckduckgo search example which was demonstrated earlier can be ported to work with Microsoft Edge WebDriver with few lines of change. Just replace IE WebDriver command with the command that invokes Microsoft Edge WebDriver and you are good to go.

***Discover the top 45 essential*** [***Vercel test cases***](https://www.lambdatest.com/learning-hub/vercel-test-case-template?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***along with its importance, types and usage for better understanding.***

```
import unittest
from selenium import webdriver
import time
from time import sleep

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

class SeachTest(unittest.TestCase):
    def setUp(self):
        # Creation of Edge WebDriver instance
        self.driver = webdriver.Edge(executable_path=r'location_of_MicrosoftWebDriver.exe')

    def test_Search(self):
        driver = self.driver
        driver.maximize_window()
        driver.get("https://duckduckgo.com/")
        elem = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.NAME, "q")))
        elem.send_keys("Lambdatest")
        elem.submit()

        sleep(10)

    def tearDown(self):
        # Close the browser.
        self.driver.close()

if __name__ == '__main__':
    unittest.main()
```
 
 

We have a look at another example of Selenium automation testing where the test framework used is Pytest. The framework can be installed by executing the command pip install pytest on the terminal. If you plan to take advantage of parallel execution, you can install the pytest-xdist plugin using the command pip install pytest-xdist. We make use of @pytest.fixture decorator with scope as a class to pass IE & Edge browsers as arguments. Since two browsers are used in the test, we use the command pytest -n=2 so that execution of IE & Microsoft Edge browser can occur in parallel.

```
import pytest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep

@pytest.fixture(params=["ie", "edge"],scope="class")

def driver_init(request):
    if request.param == "ie":
        # Local webdriver implementation with Internet Explorer (IE)
        web_driver = webdriver.Ie(executable_path=r'location_of_IEDriverServer.exe')
    if request.param == "edge":
        # Local webdriver implementation with Microsoft Edge browser (Edge)
        web_driver = webdriver.Edge(executable_path=r'location_of_MicrosoftWebDriver.exe')
    request.cls.driver = web_driver
    yield
    web_driver.close()

@pytest.mark.usefixtures("driver_init")
class BasicTest:
    pass
class Test_URL(BasicTest):
        def test_open_url(self):
            self.driver.get("https://www.lambdatest.com/")
            print(self.driver.title)

            sleep(5)
```
 

Shown below is the snapshot of the test execution where we can see that the instances of IE & Microsoft Edge browsers were initiated in parallel.

![snapshot](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/snapshot.png)

As you have seen from the examples, cross browser testing performed on local infrastructure always has limitations since you cannot perform tests on browsers of different versions e.g. Testing on IE versions 8, 9, 10, etc. on the same machine can be a big task (if not an impossible one). Also, the test of IE on Mac has many overheads around installation and efficiency of tests since they are executed in a virtual environment. Though you can have a remote Selenium Grid that can house different combinations of browsers, operating systems, and devices; it might be a scalable & economical approach. You are sure to hit a roadblock after some point when the product quality & features have improved and you might require a better & faster setup to scale up the efficiency in the test process.

***Learn 37 excellent*** [***Wix test cases***](https://www.lambdatest.com/learning-hub/wix-test-case-templates?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***for testing Wix websites by reading this guide. Every significant test case will be covered in detail in this guide, along with how to set up your Wix website testing.***

### Selenium Automation Testing on the Cloud

Irrespective of whether you are doing cross browser testing using IE, Microsoft Edge on Windows, macOS, Linux, etc.; a more viable approach is to shift to a cloud based cross-browser testing platform like LambdaTest. Using LambdaTest, you can test your web product against 2000+ real browsers and operating systems online. By making use of parallel testing with Selenium Grid on-cloud, you can execute tests at a much faster pace thereby reducing the overall turn-around involved in testing.

Here is how you can leverage LambdaTest cloud infrastructure to enhance testing of your website/web application. To get started, you need to create an account on LambdaTest. Once your account is created, you should make a note of your username & access token from [https://accounts.lambdatest.com/profile](https://accounts.lambdatest.com/profile) as that combination will be used to access the remote Selenium Grid on LambdaTest.

You can port the existing implementation that uses local Selenium WebDriver to Remote Selenium WebDriver on LambaTest with minimal changes in the code. The examples of Selenium automation testing that we have looked into so far used local Selenium WebDriver. Once you have logged into your LambdaTest account, you can have a look at the Automation tests that were triggered by you in the [Automation Tab](https://automation.lambdatest.com/?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu). Each test has a unique test-id associated with it for easy identification. In our case, we can have two concurrent sessions that can be executed in parallel. This speeds up the entire test process & results in shorter turnaround time with the faster go-to-market launch.

For demonstration, we port the earlier example that used the pytest framework to remote Selenium Grid on LambdaTest. We perform the tests using IE 8.0 on Windows 7 and Microsoft Edge 15.0 on Windows 10. The capabilities can be generated using the LambdaTest’s [Desired Capabilities Generator](https://www.lambdatest.com/capabilities-generator/). Select the appropriate browser & OS versions and generate the capabilities for Python programming language.

![Selenium Automation Testing](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/Selenium-Automation-Testing.png)

Now that the capabilities are generated, we make the relevant changes to accommodate the generated capabilities and accessing the remote Selenium Grid on LambdaTest using the username & access key combination.

```
import pytest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep
import urllib3

############# Changes for porting local Selenium WebDriver implementation to LambdaTest #############
#Set capabilities for testing on IE and Microsoft Edge
edge_capabilities = {
    "build" : "Build for testing on Microsoft Edge",
    "name" : "Microsoft Edge Testing",
    "platform" : "Windows 10",
    "browserName" : "MicrosoftEdge",
    "version" : "15.0",
    "visual" : True
}

ie_capabilities = {
    "build" : "Build for testing on Internet Explorer",
    "name" : "Internet Explorer Testing",
    "platform" : "Windows 7",
    "browserName" : "Internet Explorer",
    "version" : "8.0",
    "visual" : True,
    "ie.compatibility" : 11001
}

# Obtain the credentials from https://accounts.lambdatest.com/profile
user_name = "user-name"
app_key = "access-key"

@pytest.fixture(params=["ie", "edge"],scope="class")

def driver_init(request):
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    remote_url = "https://" + user_name + ":" + app_key + "@hub.lambdatest.com/wd/hub"
    if request.param == "ie":
        # Remote webdriver implementation with Internet Explorer (IE)
        web_driver = webdriver.Remote(command_executor=remote_url, desired_capabilities=ie_capabilities)
    if request.param == "edge":
        # Remote webdriver implementation with Microsoft Edge browser (Edge)
        web_driver = webdriver.Remote(command_executor=remote_url, desired_capabilities=edge_capabilities)
    request.cls.driver = web_driver
    yield
    web_driver.close()

@pytest.mark.usefixtures("driver_init")
class BasicTest:
    pass
class Test_URL(BasicTest):
        def test_open_url(self):
            self.driver.get("https://www.lambdatest.com/")
            print(self.driver.title) 
```


As seen in the source code, we have added capabilities of IE and Microsoft Edge browser. We login to the LambdaTest cloud platform using the username and access key. The remote URL used for accessing the LambdaTest platform and capabilities are then passed as arguments to the webdriver.Remote() API. Below is a snapshot of the execution, you can also check the Automation Tab on LambdaTest to get more information about the status of the tests.

![automation testing](https://www.lambdatest.com/blog/wp-content/uploads/2019/08/automation-testing.png)

***Discover the top 90+ essential*** [***Shopify test cases***](https://www.lambdatest.com/learning-hub/shopify-test-case-template?utm_source=devto&utm_medium=organic&utm_campaign=may04_bh&utm_term=bh&utm_content=learning_hub) ***to ensure your store’s functionality, performance, and customer experience. Download our comprehensive template now.***

## What Is Your Take At Microsoft Edge & IE?

Though Internet Explorer (IE) is deprecated, you cannot ignore cross browser testing on IE. On the other hand, the market share of Microsoft Edge is increasing steadily. Irrespective of whether you are doing development/testing on macOS, you should give priority to test IE on Mac. We have discussed multiple ways to test IE on mac, and the one with minimal effort and maximum throughput would be to go for a cloud-based [cross browser testing tool](https://www.lambdatest.com/?utm_source=dev&utm_medium=Blog&utm_campaign=Himanshu-20082019&utm_term=Himanshu) such as LambdaTest. With LambdaTest, you can perform Selenium automation testing to verify your web application’s rendering over 2000+ real browsers & browser versions running across different operating systems. This helps in speeding up every step involved in cross browser testing of your website/web application as you get all the test environments configured & readily made available for you to run your automation scripts.

I would love to know your opinion on the state of IE & Edge. Do you include them in your test cycles? Where there any specific challenges you faced while executing Selenium automation testing with IE & Edge? Let me know in the comment section. Happy testing! 🙂