Forem: Michael Mintz

The new pdbp (Pdb+) Python debugger!

Michael Mintz — Thu, 03 Aug 2023 01:38:01 +0000

Meet pdbp (Pdb+) — a new Python debugger!

pdbp (Pdb+) debugging example

SeleniumBase testing the Coffee Cart app with pdbp

Why not just use Python’s built-in pdb debugger or another existing one like ipdb or pdbpp?

Starting with pdb, it has a limited display with no color and limited abilities. Here’s Python’s built-in pdb debugger:

Regular pdb debugger

The ipdb debugger added tab completion, syntax highlighting, better tracebacks, etc. (I talked about it in a past blog post.) Here’s a sample of how it looks:

ipdb debugger

The major drawback is that it comes with a high number of external dependencies that take time to download. Here’s a pipdeptree for ipdb dependencies:

> pipdeptree
ipdb==0.13.13
├── decorator [required: Any, installed: 5.1.1]
└── ipython [required: >=7.31.1, installed: 8.14.0]
    ├── appnope [required: Any, installed: 0.1.3]
    ├── backcall [required: Any, installed: 0.2.0]
    ├── decorator [required: Any, installed: 5.1.1]
    ├── jedi [required: >=0.16, installed: 0.18.2]
    │   └── parso [required: >=0.8.0,<0.9.0, installed: 0.8.3] ├── matplotlib-inline [required: Any, installed: 0.1.6] │ └── traitlets [required: Any, installed: 5.9.0] ├── pexpect [required: >4.3, installed: 4.8.0]
    │   └── ptyprocess [required: >=0.5, installed: 0.7.0]
    ├── pickleshare [required: Any, installed: 0.7.5]
    ├── prompt-toolkit [required: >=3.0.30,<3.1.0,!=3.0.37, installed: 3.0.38] │ └── wcwidth [required: Any, installed: 0.2.6] ├── Pygments [required: >=2.4.0, installed: 2.15.1]
    ├── stack-data [required: Any, installed: 0.6.2]
    │   ├── asttokens [required: >=2.1.0, installed: 2.2.1]
    │   │   └── six [required: Any, installed: 1.16.0]
    │   ├── executing [required: >=1.2.0, installed: 1.2.0]
    │   └── pure-eval [required: Any, installed: 0.2.2]
    └── traitlets [required: >=5, installed: 5.9.0]

If you’re already using ipython, this isn’t a problem because you’ll already need to download most of these dependencies anyway. But if you’re not using ipython… you’ll still need to download those dependencies.

Up next, is the pdbpp debugger. It has tab completion, syntax highlighting, better exceptions, different modes for displaying code so that you can get a full view vs. line-by-line, etc. Here’s a sample of how it looks:

pdbpp debugger

Here’s what the main issue is: pdbpp has a dependency on fancycompleter, which has a Windows dependency on pyreadline (https://github.com/pyreadline/pyreadline), which has this issue: pyreadline/pyreadline#65, which leads to this error: AttributeError: module 'collections' has no attribute 'Callable'. This is a major problem for Windows users running Python 3.11 or newer.

Here’s what I did to fix and improve on that: (Using `pdbp`)

I created the pdbp (Pdb+) Python debugger with a dependency on my own library tabcompleter (https://github.com/mdmintz/tabcompleter), which has a dependency on the improved pyreadline3 (https://github.com/pyreadline3/pyreadline3/) instead of pyreadline. Then things started working again. As a bonus, I fixed some bugs, improved on default configuration settings, and added some new features.

Not only is it powerful, but it’s light on dependencies. Here’s a pipdeptree for `pdbp`:

> pipdeptree
pdbp==1.4.6
├── Pygments [required: >=2.16.1, installed: 2.16.1]
└── tabcompleter [required: >=1.2.1, installed: 1.2.1]

Here are a few examples of the new pdbp debugger in action:

Now that we’ve covered the differences between debuggers, let’s cover installation:

pip install pdbp (Note: pdbp is already included with seleniumbase)

Then add import pdbp to an __init__.py of your project, which will automatically make Pdb+ the default debugger at breakpoints.

Now let’s talk about using it:

Debug Mode in `pytest` can be triggered in a few different ways:

Your test raises an exception after passing the "--pdb" option to "pytest".
The moment your test begins after passing the "--trace" option to "pytest".
Calling "pdb.set_trace()" or "pdbp.set_trace()" from your test after importing "pdb" or "pdbp" respectively. (Calling the "breakpoint()" method also works.)
At the end of a test if you added the "--final-debug" or "--ftrace" options to "pytest". (SeleniumBase-only)

When Debug Mode is activated, the browser window will remain open (when used in combination with browser automation), and you can see how variables look from the command-line.

(Note that you may need to add "-s" to your "pytest" run command to allow breakpoints, unless you already have a "pytest.ini" file present with "addops = --capture=no" in it.)

Once you’re in Debug Mode, there are several commands that you can use in order to control and debug tests:

n (next): Execute the next line of the current method block.
s (step): Step through and execute the next line of the current method block (but if the current method calls another method, go down the stack).
c (continue): Leave Debug Mode and continue the test where the current method left off.
r (return): Continue running the test until the current method returns.
j (jump): Jump to the line number of the current method block.
w (where): Show where you are within the current stack trace.
u (up): Move up the stack.
d (down): Move down the stack.
ll (longlist): See the code for the current method block.
dir(): List namespace objects.
h (help): List all available commands.

Here are some new commands added by `pdbp`:

sticky: Toggle between sticky and non-sticky mode, which shows full code blocks vs individual lines in a stack.
trun (truncate): Use this to toggle between truncating or not truncating long lines in sticky mode.

Additionally, you can execute any Python code that you want from within Debug Mode. (Assuming your code can be run in a single line.)

Now that you’ve covered the basics on using pdbp, see the pdbp GitHub ReadMe for more details.

And for Python browser automation, see the SeleniumBase GitHub page!

Solving the "Wordle" Game using Python and Selenium

Michael Mintz — Thu, 20 Jan 2022 15:25:40 +0000

If you're looking for a complete Python Selenium solution for solving the Wordle Game programmatically, here's one that uses the SeleniumBase framework. The solution comes with a YouTube video, as well as the Python code of the solution, and a GIF of what to expect:

The code uses special SeleniumBase ::shadow selectors in order to pierce through multiple layers of Shadow-DOM. Here's the code below, which can be run after calling pip install seleniumbase to get all the Python dependencies: (Updated 2/11/22 - after NYT acquired Wordle; Updated again on 2/13/22 to fix font issue on some Python environments; Updated again on 7/1/22 to use web-archived versions of Wordle because NYT removed the Shadow-DOM elements from the latest Wordle.)

"""
Solve the Wordle game using SeleniumBase.
This test runs on archived versions of Wordle, containing Shadow-DOM.
"""

import ast
import random
import requests
from seleniumbase import version_tuple
from seleniumbase import BaseCase


class WordleTests(BaseCase):

    word_list = []

    def initialize_word_list(self):
        txt_file = "https://seleniumbase.github.io/cdn/txt/wordle_words.txt"
        word_string = requests.get(txt_file).text
        self.word_list = ast.literal_eval(word_string)

    def modify_word_list(self, word, letter_status):
        new_word_list = []
        correct_letters = []
        present_letters = []
        for i in range(len(word)):
            if letter_status[i] == "correct":
                correct_letters.append(word[i])
                for w in self.word_list:
                    if w[i] == word[i]:
                        new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []
        for i in range(len(word)):
            if letter_status[i] == "present":
                present_letters.append(word[i])
                for w in self.word_list:
                    if word[i] in w and word[i] != w[i]:
                        new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []
        for i in range(len(word)):
            if letter_status[i] == "absent":
                if (
                    word[i] not in correct_letters
                    and word[i] not in present_letters
                ):
                    for w in self.word_list:
                        if word[i] not in w:
                            new_word_list.append(w)
                else:
                    for w in self.word_list:
                        if word[i] != w[i]:
                            new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []

    def skip_if_incorrect_env(self):
        if self.headless:
            message = "This test doesn't run in headless mode!"
            print(message)
            self.skip(message)
        if not self.is_chromium():
            message = "This test requires a Chromium-based browser!"
            print(message)
            self.skip(message)
        if version_tuple < (4, 0, 0):
            message = "This test requires SeleniumBase 4.0.0 or newer!"
            print(message)
            self.skip(message)

    def test_wordle(self):
        self.skip_if_incorrect_env()
        random.seed()
        year = "2022"
        month = random.randint(3, 5)
        day = random.randint(1, 30)
        date = str(year) + "0" + str(month) + str(day)
        archive = "https://web.archive.org/web/"
        url = "https://www.nytimes.com/games/wordle/index.html"
        past_wordle = archive + date + "/" + url
        print("\n" + past_wordle)
        self.open(past_wordle)
        self.wait_for_element("#wm-ipp-base")
        self.remove_elements("#wm-ipp-base")
        self.click("game-app::shadow game-modal::shadow game-icon")
        self.initialize_word_list()
        keyboard_base = "game-app::shadow game-keyboard::shadow "
        word = random.choice(self.word_list)
        num_attempts = 0
        found_word = False
        for attempt in range(6):
            num_attempts += 1
            word = random.choice(self.word_list)
            letters = []
            for letter in word:
                letters.append(letter)
                button = 'button[data-key="%s"]' % letter
                self.click(keyboard_base + button)
            button = "button.one-and-a-half"
            self.click(keyboard_base + button)
            row = 'game-app::shadow game-row[letters="%s"]::shadow ' % word
            tile = row + "game-tile:nth-of-type(%s)"
            self.wait_for_element(tile % "5" + '::shadow [data-state$="t"]')
            self.wait_for_element(
                tile % "5" + '::shadow [data-animation="idle"]'
            )
            letter_status = []
            for i in range(1, 6):
                letter_eval = self.get_attribute(tile % str(i), "evaluation")
                letter_status.append(letter_eval)
            if letter_status.count("correct") == 5:
                found_word = True
                break
            self.word_list.remove(word)
            self.modify_word_list(word, letter_status)

        self.save_screenshot_to_logs()
        if found_word:
            print('Word: "%s"\nAttempts: %s' % (word.upper(), num_attempts))
        else:
            print('Final guess: "%s" (Not the correct word!)' % word.upper())
            self.fail("Unable to solve for the correct word in 6 attempts!")
        self.sleep(3)

Note that SeleniumBase tests are run using pytest. Also, the Wordle website appears slightly differently when opened using headless Chrome, so don't use Chrome's headless mode when running this example.

Have fun solving "Wordle" with SeleniumBase using Python and Selenium!

Here's a script that works on the latest version of Wordle, which removed the Shadow-DOM elements:

"""Solve Wordle with SeleniumBase."""
import ast
import random
import requests
from seleniumbase import BaseCase


class WordleTests(BaseCase):

    word_list = []

    def initialize_word_list(self):
        txt_file = "https://seleniumbase.github.io/cdn/txt/wordle_words.txt"
        word_string = requests.get(txt_file).text
        self.word_list = ast.literal_eval(word_string)

    def modify_word_list(self, word, letter_status):
        new_word_list = []
        correct_letters = []
        present_letters = []
        for i in range(len(word)):
            if letter_status[i] == "correct":
                correct_letters.append(word[i])
                for w in self.word_list:
                    if w[i] == word[i]:
                        new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []
        for i in range(len(word)):
            if letter_status[i] == "present":
                present_letters.append(word[i])
                for w in self.word_list:
                    if word[i] in w and word[i] != w[i]:
                        new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []
        for i in range(len(word)):
            if letter_status[i] == "absent":
                if (
                    word[i] not in correct_letters
                    and word[i] not in present_letters
                ):
                    for w in self.word_list:
                        if word[i] not in w:
                            new_word_list.append(w)
                else:
                    for w in self.word_list:
                        if word[i] != w[i]:
                            new_word_list.append(w)
                self.word_list = new_word_list
                new_word_list = []

    def test_wordle(self):
        self.open("https://www.nytimes.com/games/wordle/index.html")
        self.click_if_visible('svg[data-testid="icon-close"]', timeout=2)
        self.remove_elements("div.place-ad")
        self.initialize_word_list()
        random.seed()
        word = random.choice(self.word_list)
        num_attempts = 0
        found_word = False
        for attempt in range(6):
            num_attempts += 1
            word = random.choice(self.word_list)
            letters = []
            for letter in word:
                letters.append(letter)
                button = 'button[data-key="%s"]' % letter
                self.click(button)
            button = 'button[class*="oneAndAHalf"]'
            self.click(button)
            row = (
                'div[class*="Board"] div[class*="Row-module"]:nth-of-type(%s) '
                % num_attempts
            )
            tile = row + 'div:nth-child(%s) div[class*="module_tile__"]'
            self.wait_for_element(tile % "5" + '[data-state$="t"]')
            self.wait_for_element(tile % "5" + '[data-animation="idle"]')
            letter_status = []
            for i in range(1, 6):
                letter_eval = self.get_attribute(tile % str(i), "data-state")
                letter_status.append(letter_eval)
            if letter_status.count("correct") == 5:
                found_word = True
                break
            self.word_list.remove(word)
            self.modify_word_list(word, letter_status)

        self.save_screenshot_to_logs()
        if found_word:
            print('\nWord: "%s"\nAttempts: %s' % (word.upper(), num_attempts))
        else:
            print('Final guess: "%s" (Not the correct word!)' % word.upper())
            self.fail("Unable to solve for the correct word in 6 attempts!")
        self.sleep(3)

The 23 syntax formats of SeleniumBase

Michael Mintz — Mon, 28 Dec 2020 15:33:32 +0000

The 23 syntax formats / design patterns

(Watch this tutorial on YouTube)

SeleniumBase currently supports 23 unique syntax formats (AKA "design patterns") for structuring tests.

Table of Contents / Navigation:

01. BaseCase direct class inheritance

02. BaseCase subclass inheritance

03. The "sb" pytest fixture (no class)

04. The "sb" pytest fixture (in class)

05. Page Object Model with BaseCase

06. Page Object Model with the "sb" fixture

07. Using "request" to get "sb" (no class)

08. Using "request" to get "sb" (in class)

09. Overriding the driver via BaseCase

10. Overriding the driver via "sb" fixture

11. BaseCase with Chinese translations

12. BaseCase with Dutch translations

13. BaseCase with French translations

14. BaseCase with Italian translations

15. BaseCase with Japanese translations

16. BaseCase with Korean translations

17. BaseCase with Portuguese translations

18. BaseCase with Russian translations

19. BaseCase with Spanish translations

20. Gherkin syntax with "behave" BDD runner

21. SeleniumBase SB (Python context manager)

22. The driver manager (via context manager)

23. The driver manager (via direct import)

1. BaseCase direct class inheritance

This format is used by most of the examples in the SeleniumBase examples folder. It's a great starting point for anyone learning SeleniumBase, and it follows good object-oriented programming principles. In this format, BaseCase is imported at the top of a Python file, followed by a Python class inheriting BaseCase. Then, any test method defined in that class automatically gains access to SeleniumBase methods, including the setUp() and tearDown() methods that are automatically called to spin up and spin down web browsers at the beginning and end of test methods. Here's an example of that:

from seleniumbase import BaseCase

class MyTestClass(BaseCase):
    def test_demo_site(self):
        self.open("https://seleniumbase.io/demo_page")
        self.type("#myTextInput", "This is Automated")
        self.click("#myButton")
        self.assert_element("tbody#tbodyId")
        self.assert_text("Automation Practice", "h3")
        self.click_link("SeleniumBase Demo Page")
        self.assert_exact_text("Demo Page", "h1")
        self.assert_no_js_errors()

(See examples/test_demo_site.py for the full test.)

2. BaseCase subclass inheritance

There are situations where you may want to customize the setUp and tearDown of your tests. Maybe you want to have all your tests login to a specific web site first, or maybe you want to have your tests report results through an API call depending on whether a test passed or failed. This can be done by creating a subclass of BaseCase and then carefully creating custom setUp() and tearDown() methods that don't overwrite the critical functionality of the default SeleniumBase setUp() and tearDown() methods. Afterwards, your test classes will inherit the subclass of BaseCase with the added functionality, rather than directly inheriting BaseCase itself. Here's an example of that:

from seleniumbase import BaseCase

class BaseTestCase(BaseCase):
    def setUp(self):
        super(BaseTestCase, self).setUp()
        # <<< Run custom setUp() code for tests AFTER the super().setUp() >>>

    def tearDown(self):
        self.save_teardown_screenshot()  # If test fails, or if "--screenshot"
        if self.has_exception():
            # <<< Run custom code if the test failed. >>>
            pass
        else:
            # <<< Run custom code if the test passed. >>>
            pass
        # (Wrap unreliable tearDown() code in a try/except block.)
        # <<< Run custom tearDown() code BEFORE the super().tearDown() >>>
        super(BaseTestCase, self).tearDown()

    def login(self):
        # <<< Placeholder. Add your code here. >>>
        # Reduce duplicate code in tests by having reusable methods like this.
        # If the UI changes, the fix can be applied in one place.
        pass

    def example_method(self):
        # <<< Placeholder. Add your code here. >>>
        pass

class MyTests(BaseTestCase):
    def test_example(self):
        self.login()
        self.example_method()
        self.type("input", "Name")
        self.click("form button")
        ...

(See examples/boilerplates/base_test_case.py for more info.)

3. The "sb" pytest fixture (no class)

The pytest framework comes with a unique system called fixtures, which replaces import statements at the top of Python files by importing libraries directly into test definitions. More than just being an import, a pytest fixture can also automatically call predefined setUp() and tearDown() methods at the beginning and end of test methods. To work, sb is added as an argument to each test method definition that needs SeleniumBase functionality. This means you no longer need import statements in your Python files to use SeleniumBase. If using other pytest fixtures in your tests, you may need to use the SeleniumBase fixture (instead of BaseCase class inheritance) for compatibility reasons. Here's an example of the sb fixture in a test that does not use Python classes:

def test_sb_fixture_with_no_class(sb):
    sb.open("https://google.com/ncr")
    sb.type('[title="Search"]', 'SeleniumBase\n')
    sb.click('a[href*="github.com/seleniumbase/SeleniumBase"]')
    sb.click('a[title="seleniumbase"]')

(See the top of examples/test_sb_fixture.py for the test.)

4. The "sb" pytest fixture (in class)

The sb pytest fixture can also be used inside of a class. There is a slight change to the syntax because that means test methods must also include self in their argument definitions when test methods are defined. (The self argument represents the class object, and is used in every test method that lives inside of a class.) Once again, no import statements are needed in your Python files for this to work. Here's an example of using the sb fixture in a test method that lives inside of a Python class:

class Test_SB_Fixture:
    def test_sb_fixture_inside_class(self, sb):
        sb.open("https://google.com/ncr")
        sb.type('[title="Search"]', 'SeleniumBase\n')
        sb.click('a[href*="github.com/seleniumbase/SeleniumBase"]')
        sb.click('a[title="examples"]')

(See the bottom of examples/test_sb_fixture.py for the test.)

5. Page Object Model with BaseCase

With SeleniumBase, you can use Page Objects to break out code from tests, but remember, the self variable (from test methods that inherit BaseCase) contains the driver and all other framework-specific variable definitions. Therefore, that self must be passed as an arg into any outside class method in order to call SeleniumBase methods from there. In the example below, the self variable from the test method is passed into the sb arg of the Page Object class method because the self arg of the Page Object class method is already being used for its own class. Every Python class method definition must include the self as the first arg.

from seleniumbase import BaseCase

class LoginPage:
    def login_to_swag_labs(self, sb, username):
        sb.open("https://www.saucedemo.com")
        sb.type("#user-name", username)
        sb.type("#password", "secret_sauce")
        sb.click('input[type="submit"]')

class MyTests(BaseCase):
    def test_swag_labs_login(self):
        LoginPage().login_to_swag_labs(self, "standard_user")
        self.assert_element("div.inventory_list")
        self.assert_element('div:contains("Sauce Labs Backpack")')

(See examples/boilerplates/samples/swag_labs_test.py for the full test.)

6. Page Object Model with the "sb" fixture

This is similar to the classic Page Object Model with BaseCase inheritance, except that this time we pass the sb pytest fixture from the test into the sb arg of the page object class method, (instead of passing self). Now that you're using sb as a pytest fixture, you no longer need to import BaseCase anywhere in your code. See the example below:

class LoginPage:
    def login_to_swag_labs(self, sb, username):
        sb.open("https://www.saucedemo.com")
        sb.type("#user-name", username)
        sb.type("#password", "secret_sauce")
        sb.click('input[type="submit"]')

class MyTests:
    def test_swag_labs_login(self, sb):
        LoginPage().login_to_swag_labs(sb, "standard_user")
        sb.assert_element("div.inventory_list")
        sb.assert_element('div:contains("Sauce Labs Backpack")')

(See examples/boilerplates/samples/sb_swag_test.py for the full test.)

7. Using "request" to get "sb" (no class)

The pytest request fixture can be used to retrieve other pytest fixtures from within tests, such as the sb fixture. This allows you to have more control over when fixtures get initialized because the fixture no longer needs to be loaded at the very beginning of test methods. This is done by calling request.getfixturevalue('sb') from the test. Here's an example of using the pytest request fixture to load the sb fixture in a test method that does not use Python classes:

def test_request_sb_fixture(request):
    sb = request.getfixturevalue('sb')
    sb.open("https://seleniumbase.io/demo_page")
    sb.assert_text("SeleniumBase", "#myForm h2")
    sb.assert_element("input#myTextInput")
    sb.type("#myTextarea", "This is me")
    sb.click("#myButton")
    sb.tearDown()

(See the top of examples/test_request_sb_fixture.py for the test.)

8. Using "request" to get "sb" (in class)

The pytest request fixture can also be used to get the sb fixture from inside a Python class. Here's an example of that:

class Test_Request_Fixture:
    def test_request_sb_fixture_in_class(self, request):
        sb = request.getfixturevalue('sb')
        sb.open("https://seleniumbase.io/demo_page")
        sb.assert_element("input#myTextInput")
        sb.type("#myTextarea", "Automated")
        sb.assert_text("This Text is Green", "#pText")
        sb.click("#myButton")
        sb.assert_text("This Text is Purple", "#pText")
        sb.tearDown()

(See the bottom of examples/test_request_sb_fixture.py for the test.)

9. Overriding the driver via BaseCase

When you want to use SeleniumBase methods via BaseCase, but you want total freedom to control how you spin up your web browsers, this is the format you want. Although SeleniumBase gives you plenty of command-line options to change how your browsers are launched, this format gives you more control when the existing options aren't enough. Here's an example of that:

from selenium import webdriver
from seleniumbase import BaseCase

class OverrideDriverTest(BaseCase):
    def get_new_driver(self, *args, **kwargs):
        """This method overrides get_new_driver() from BaseCase."""
        options = webdriver.ChromeOptions()
        options.add_argument("--disable-3d-apis")
        options.add_argument("--disable-notifications")
        if self.headless:
            options.add_argument("--headless")
            options.add_argument("--disable-gpu")
        options.add_experimental_option(
            "excludeSwitches", ["enable-automation", "enable-logging"],
        )
        prefs = {
            "credentials_enable_service": False,
            "profile.password_manager_enabled": False,
        }
        options.add_experimental_option("prefs", prefs)
        return webdriver.Chrome(options=options)

    def test_simple(self):
        self.open("https://seleniumbase.io/demo_page")
        self.assert_text("Demo Page", "h1")

(From examples/test_override_driver.py)

The above format can let you use selenium-wire to intercept & inspect requests and responses during SeleniumBase tests. Here's how the selenium-wire integration may look:

from seleniumbase import BaseCase
from seleniumwire import webdriver  # Requires "pip install selenium-wire"


class WireTestCase(BaseCase):
    def get_new_driver(self, *args, **kwargs):
        options = webdriver.ChromeOptions()
        options.add_experimental_option(
            "excludeSwitches", ["enable-automation"]
        )
        options.add_experimental_option("useAutomationExtension", False)
        return webdriver.Chrome(options=options)

    def test_simple(self):
        self.open("https://seleniumbase.io/demo_page")
        for request in self.driver.requests:
            print(request.url)

10. Overriding the driver via "sb" fixture

When you want to use SeleniumBase methods via the sb pytest fixture, but you want total freedom to control how you spin up your web browsers, this is the format you want. Although SeleniumBase gives you plenty of command-line options to change how your browsers are launched, this format gives you more control when the existing options aren't enough.

"""Overriding the "sb" fixture to override the driver."""
import pytest

@pytest.fixture()
def sb(request):
    from selenium import webdriver
    from seleniumbase import BaseCase
    from seleniumbase import config as sb_config

    class BaseClass(BaseCase):
        def get_new_driver(self, *args, **kwargs):
            """This method overrides get_new_driver() from BaseCase."""
            options = webdriver.ChromeOptions()
            if self.headless:
                options.add_argument("--headless=new")
                options.add_argument("--disable-gpu")
            options.add_experimental_option(
                "excludeSwitches", ["enable-automation"],
            )
            return webdriver.Chrome(options=options)

        def setUp(self):
            super().setUp()

        def base_method(self):
            pass

        def tearDown(self):
            self.save_teardown_screenshot()  # On failure or "--screenshot"
            super().tearDown()

    if request.cls:
        request.cls.sb = BaseClass("base_method")
        request.cls.sb.setUp()
        request.cls.sb._needs_tearDown = True
        request.cls.sb._using_sb_fixture = True
        request.cls.sb._using_sb_fixture_class = True
        sb_config._sb_node[request.node.nodeid] = request.cls.sb
        yield request.cls.sb
        if request.cls.sb._needs_tearDown:
            request.cls.sb.tearDown()
            request.cls.sb._needs_tearDown = False
    else:
        sb = BaseClass("base_method")
        sb.setUp()
        sb._needs_tearDown = True
        sb._using_sb_fixture = True
        sb._using_sb_fixture_no_class = True
        sb_config._sb_node[request.node.nodeid] = sb
        yield sb
        if sb._needs_tearDown:
            sb.tearDown()
            sb._needs_tearDown = False

def test_override_fixture_no_class(sb):
    sb.open("https://seleniumbase.io/demo_page")
    sb.type("#myTextInput", "This is Automated")

class TestOverride:
    def test_override_fixture_inside_class(self, sb):
        sb.open("https://seleniumbase.io/demo_page")
        sb.type("#myTextInput", "This is Automated")

(From examples/test_override_sb_fixture.py)

Here's how the selenium-wire integration may look when overriding the sb pytest fixture to override the driver:

import pytest

@pytest.fixture()
def sb(request):
    import sys
    from seleniumbase import BaseCase
    from seleniumbase import config as sb_config
    from seleniumwire import webdriver  # Requires "pip install selenium-wire"

    class BaseClass(BaseCase):
        def get_new_driver(self, *args, **kwargs):
            options = webdriver.ChromeOptions()
            if "linux" in sys.platform:
                options.add_argument("--headless=new")
            options.add_experimental_option(
                "excludeSwitches", ["enable-automation"],
            )
            return webdriver.Chrome(options=options)

        def setUp(self):
            super().setUp()

        def tearDown(self):
            self.save_teardown_screenshot()  # On failure or "--screenshot"
            super().tearDown()

        def base_method(self):
            pass

    if request.cls:
        request.cls.sb = BaseClass("base_method")
        request.cls.sb.setUp()
        request.cls.sb._needs_tearDown = True
        request.cls.sb._using_sb_fixture = True
        request.cls.sb._using_sb_fixture_class = True
        sb_config._sb_node[request.node.nodeid] = request.cls.sb
        yield request.cls.sb
        if request.cls.sb._needs_tearDown:
            request.cls.sb.tearDown()
            request.cls.sb._needs_tearDown = False
    else:
        sb = BaseClass("base_method")
        sb.setUp()
        sb._needs_tearDown = True
        sb._using_sb_fixture = True
        sb._using_sb_fixture_no_class = True
        sb_config._sb_node[request.node.nodeid] = sb
        yield sb
        if sb._needs_tearDown:
            sb.tearDown()
            sb._needs_tearDown = False

def test_wire_with_no_class(sb):
    sb.open("https://seleniumbase.io/demo_page")
    for request in sb.driver.requests:
        print(request.url)

class TestWire:
    def test_wire_inside_class(self, sb):
        sb.open("https://seleniumbase.io/demo_page")
        for request in sb.driver.requests:
            print(request.url)

11. BaseCase with Chinese translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Chinese. Here's an example of that:

from seleniumbase.translate.chinese import 硒测试用例

class 我的测试类(硒测试用例):
    def test_例子1(self):
        self.开启("https://zh.wikipedia.org/wiki/")
        self.断言标题("维基百科，自由的百科全书")
        self.断言元素('a[title="Wikipedia:关于"]')
        self.断言文本("新闻动态", "span#新闻动态")
        self.输入文本('input[name="search"]', "舞龍")
        self.单击('button:contains("搜索")')
        self.断言文本("舞龍", "#firstHeading")
        self.断言元素('img[src*="Chinese_draak.jpg"]')
        self.回去()
        self.输入文本('input[name="search"]', "麻婆豆腐")
        self.单击('button:contains("搜索")')
        self.断言文本("麻婆豆腐", "#firstHeading")
        self.断言元素('figure:contains("一家中餐館的麻婆豆腐")')
        self.回去()
        self.输入文本('input[name="search"]', "精武英雄")
        self.单击('button:contains("搜索")')
        self.断言元素('img[src*="Fist_of_legend.jpg"]')
        self.断言文本("李连杰", 'li a[title="李连杰"]')

(See examples/translations/chinese_test_1.py for the Chinese test.)

12. BaseCase with Dutch translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Dutch. Here's an example of that:

from seleniumbase.translate.dutch import Testgeval

class MijnTestklasse(Testgeval):
    def test_voorbeeld_1(self):
        self.openen("https://nl.wikipedia.org/wiki/Hoofdpagina")
        self.controleren_element('a[title*="hoofdpagina gaan"]')
        self.controleren_tekst("Welkom op Wikipedia", "td.hp-welkom")
        self.typ("#searchInput", "Stroopwafel")
        self.klik("#searchButton")
        self.controleren_tekst("Stroopwafel", "#firstHeading")
        self.controleren_element('img[src*="Stroopwafels"]')
        self.typ("#searchInput", "Rijksmuseum Amsterdam")
        self.klik("#searchButton")
        self.controleren_tekst("Rijksmuseum", "#firstHeading")
        self.controleren_element('img[src*="Rijksmuseum"]')
        self.terug()
        self.controleren_url_bevat("Stroopwafel")
        self.vooruit()
        self.controleren_url_bevat("Rijksmuseum")

(See examples/translations/dutch_test_1.py for the Dutch test.)

13. BaseCase with French translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into French. Here's an example of that:

from seleniumbase.translate.french import CasDeBase

class MaClasseDeTest(CasDeBase):
    def test_exemple_1(self):
        self.ouvrir("https://fr.wikipedia.org/wiki/")
        self.vérifier_texte("Wikipédia")
        self.vérifier_élément('[alt="Wikipédia"]')
        self.js_taper("#searchform input", "Crème brûlée")
        self.cliquer("#searchform button")
        self.vérifier_texte("Crème brûlée", "#firstHeading")
        self.vérifier_élément('img[alt*="Crème brûlée"]')
        self.js_taper("#searchform input", "Jardin des Tuileries")
        self.cliquer("#searchform button")
        self.vérifier_texte("Jardin des Tuileries", "#firstHeading")
        self.vérifier_élément('img[alt*="Jardin des Tuileries"]')
        self.retour()
        self.vérifier_url_contient("brûlée")
        self.en_avant()
        self.vérifier_url_contient("Jardin")

(See examples/translations/french_test_1.py for the French test.)

14. BaseCase with Italian translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Italian. Here's an example of that:

from seleniumbase.translate.italian import CasoDiProva

class MiaClasseDiTest(CasoDiProva):
    def test_esempio_1(self):
        self.apri("https://it.wikipedia.org/wiki/")
        self.verificare_testo("Wikipedia")
        self.verificare_elemento('a[title="Lingua italiana"]')
        self.digitare("#searchInput", "Pizza")
        self.fare_clic("#searchButton")
        self.verificare_testo("Pizza", "#firstHeading")
        self.verificare_elemento('figure img[src*="pizza"]')
        self.digitare("#searchInput", "Colosseo")
        self.fare_clic("#searchButton")
        self.verificare_testo("Colosseo", "#firstHeading")
        self.verificare_elemento('figure img[src*="Colosseo"]')
        self.indietro()
        self.verificare_url_contiene("Pizza")
        self.avanti()
        self.verificare_url_contiene("Colosseo")

(See examples/translations/italian_test_1.py for the Italian test.)

15. BaseCase with Japanese translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Japanese. Here's an example of that:

from seleniumbase.translate.japanese import セレニウムテストケース

class 私のテストクラス(セレニウムテストケース):
    def test_例1(self):
        self.を開く("https://ja.wikipedia.org/wiki/")
        self.テキストを確認する("ウィキペディア")
        self.要素を確認する('[title*="ウィキペディアへようこそ"]')
        self.JS入力('input[name="search"]', "アニメ")
        self.クリックして("#searchform button")
        self.テキストを確認する("アニメ", "#firstHeading")
        self.JS入力('input[name="search"]', "寿司")
        self.クリックして("#searchform button")
        self.テキストを確認する("寿司", "#firstHeading")
        self.要素を確認する('img[alt="握り寿司"]')
        self.JS入力("#searchInput", "レゴランド・ジャパン")
        self.クリックして("#searchform button")
        self.要素を確認する('img[src*="LEGOLAND_JAPAN"]')
        self.リンクテキストを確認する("名古屋城")
        self.リンクテキストをクリックします("テーマパーク")
        self.テキストを確認する("テーマパーク", "#firstHeading")

(See examples/translations/japanese_test_1.py for the Japanese test.)

16. BaseCase with Korean translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Korean. Here's an example of that:

from seleniumbase.translate.korean import 셀레늄_테스트_케이스

class 테스트_클래스(셀레늄_테스트_케이스):
    def test_실시예_1(self):
        self.열기("https://ko.wikipedia.org/wiki/")
        self.텍스트_확인("위키백과")
        self.요소_확인('[title="위키백과:소개"]')
        self.JS_입력("#searchform input", "김치")
        self.클릭("#searchform button")
        self.텍스트_확인("김치", "#firstHeading")
        self.요소_확인('img[src*="Various_kimchi.jpg"]')
        self.링크_텍스트_확인("한국 요리")
        self.JS_입력("#searchform input", "비빔밥")
        self.클릭("#searchform button")
        self.텍스트_확인("비빔밥", "#firstHeading")
        self.요소_확인('img[src*="Dolsot-bibimbap.jpg"]')
        self.링크_텍스트를_클릭합니다("돌솥비빔밥")
        self.텍스트_확인("돌솥비빔밥", "#firstHeading")

(See examples/translations/korean_test_1.py for the Korean test.)

17. BaseCase with Portuguese translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Portuguese. Here's an example of that:

from seleniumbase.translate.portuguese import CasoDeTeste

class MinhaClasseDeTeste(CasoDeTeste):
    def test_exemplo_1(self):
        self.abrir("https://pt.wikipedia.org/wiki/")
        self.verificar_texto("Wikipédia")
        self.verificar_elemento('[title="Língua portuguesa"]')
        self.digitar("#searchform input", "João Pessoa")
        self.clique("#searchform button")
        self.verificar_texto("João Pessoa", "#firstHeading")
        self.verificar_elemento('img[alt*="João Pessoa"]')
        self.digitar("#searchform input", "Florianópolis")
        self.clique("#searchform button")
        self.verificar_texto("Florianópolis", "h1#firstHeading")
        self.verificar_elemento('td:contains("Avenida Beira-Mar")')
        self.voltar()
        self.verificar_url_contém("João_Pessoa")
        self.atualizar_a_página()
        self.js_digitar("#searchform input", "Teatro Amazonas")
        self.clique("#searchform button")
        self.verificar_texto("Teatro Amazonas", "#firstHeading")
        self.verificar_texto_do_link("Festival Amazonas de Ópera")

(See examples/translations/portuguese_test_1.py for the Portuguese test.)

18. BaseCase with Russian translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Russian. Here's an example of that:

from seleniumbase.translate.russian import ТестНаСелен

class МойТестовыйКласс(ТестНаСелен):
    def test_пример_1(self):
        self.открыть("https://ru.wikipedia.org/wiki/")
        self.подтвердить_элемент('[title="Русский язык"]')
        self.подтвердить_текст("Википедия", "h2.main-wikimedia-header")
        self.введите("#searchInput", "МГУ")
        self.нажмите("#searchButton")
        self.подтвердить_текст("университет", "#firstHeading")
        self.подтвердить_элемент('img[alt*="Главное здание МГУ"]')
        self.введите("#searchInput", "приключения Шурика")
        self.нажмите("#searchButton")
        self.подтвердить_текст("Операция «Ы» и другие приключения Шурика")
        self.подтвердить_элемент('img[alt="Постер фильма"]')
        self.назад()
        self.подтвердить_URL_содержит("университет")
        self.вперед()
        self.подтвердить_URL_содержит("Шурика")

(See examples/translations/russian_test_1.py for the Russian test.)

19. BaseCase with Spanish translations

This format is similar to the English version with BaseCase inheritance, but there's a different import statement, and method names have been translated into Spanish. Here's an example of that:

from seleniumbase.translate.spanish import CasoDePrueba

class MiClaseDePrueba(CasoDePrueba):
    def test_ejemplo_1(self):
        self.abrir("https://es.wikipedia.org/wiki/")
        self.verificar_texto("Wikipedia")
        self.verificar_elemento('[title="Wikipedia:Bienvenidos"]')
        self.escriba('[name="search"]', "Parque de Atracciones Tibidabo")
        self.haga_clic('button:contains("Buscar")')
        self.verificar_texto("Tibidabo", "#firstHeading")
        self.verificar_elemento('img[src*="Tibidabo"]')
        self.escriba('input[name="search"]', "Palma de Mallorca")
        self.haga_clic('button:contains("Buscar")')
        self.verificar_texto("Palma de Mallorca", "#firstHeading")
        self.verificar_elemento('img[src*="Palma"]')
        self.volver()
        self.verificar_url_contiene("Tibidabo")
        self.adelante()
        self.verificar_url_contiene("Mallorca")

(See examples/translations/spanish_test_1.py for the Spanish test.)

20. Gherkin syntax with "behave" BDD runner

With Behave's BDD Gherkin format, you can use natural language to write tests that work with SeleniumBase methods. Behave tests are run by calling behave on the command-line. This requires some special files in a specific directory structure. Here's an example of that structure:

features/
├── __init__.py
├── behave.ini
├── environment.py
├── feature_file.feature
└── steps/
    ├── __init__.py
    ├── imported.py
    └── step_file.py

A *.feature file might look like this:

Feature: SeleniumBase scenarios for the RealWorld App

  Scenario: Verify RealWorld App (log in / sign out)
    Given Open "seleniumbase.io/realworld/login"
    And Clear Session Storage
    When Type "demo_user" into "#username"
    And Type "secret_pass" into "#password"
    And Do MFA "GAXG2MTEOR3DMMDG" into "#totpcode"
    Then Assert exact text "Welcome!" in "h1"
    And Highlight "img#image1"
    And Click 'a:contains("This Page")'
    And Save screenshot to logs
    When Click link "Sign out"
    Then Assert element 'a:contains("Sign in")'
    And Assert text "You have been signed out!"

(From examples/behave_bdd/features/realworld.feature)

You'll need the environment.py file for tests to work. Here it is:

from seleniumbase import BaseCase
from seleniumbase.behave import behave_sb
behave_sb.set_base_class(BaseCase)  # Accepts a BaseCase subclass
from seleniumbase.behave.behave_sb import before_all  # noqa
from seleniumbase.behave.behave_sb import before_feature  # noqa
from seleniumbase.behave.behave_sb import before_scenario  # noqa
from seleniumbase.behave.behave_sb import before_step  # noqa
from seleniumbase.behave.behave_sb import after_step  # noqa
from seleniumbase.behave.behave_sb import after_scenario  # noqa
from seleniumbase.behave.behave_sb import after_feature  # noqa
from seleniumbase.behave.behave_sb import after_all  # noqa

(From examples/behave_bdd/features/environment.py)

Inside that file, you can use BaseCase (or a subclass) for the inherited class.

For your behave tests to have access to SeleniumBase Behave steps, you can create an imported.py file with the following line:

from seleniumbase.behave import steps  # noqa

That will allow you to use lines like this in your *.feature files:

Feature: SeleniumBase scenarios for the RealWorld App

  Scenario: Verify RealWorld App (log in / sign out)
    Given Open "seleniumbase.io/realworld/login"
    And Clear Session Storage
    When Type "demo_user" into "#username"
    And Type "secret_pass" into "#password"
    And Do MFA "GAXG2MTEOR3DMMDG" into "#totpcode"
    Then Assert exact text "Welcome!" in "h1"
    And Highlight "img#image1"
    And Click 'a:contains("This Page")'
    And Save screenshot to logs

You can also create your own step files (Eg. step_file.py):

from behave import step

@step("Open the Swag Labs Login Page")
def go_to_swag_labs(context):
    sb = context.sb
    sb.open("https://www.saucedemo.com")
    sb.clear_local_storage()

@step("Login to Swag Labs with {user}")
def login_to_swag_labs(context, user):
    sb = context.sb
    sb.type("#user-name", user)
    sb.type("#password", "secret_sauce\n")

(For more information, see the SeleniumBase Behave BDD ReadMe.)

21. SeleniumBase SB (Python context manager)

This format provides a pure Python way of using SeleniumBase without a test runner. Options can be passed via method instantiation or from the command-line. When setting the test option to True (or calling python --test), then standard test logging will occur, such as screenshots and reports for failing tests. All the usual SeleniumBase options are available, such as customizing the browser settings, etc. Here are some examples:

from seleniumbase import SB

with SB() as sb:  # By default, browser="chrome" if not set.
    sb.open("https://seleniumbase.github.io/realworld/login")
    sb.type("#username", "demo_user")
    sb.type("#password", "secret_pass")
    sb.enter_mfa_code("#totpcode", "GAXG2MTEOR3DMMDG")  # 6-digit
    sb.assert_text("Welcome!", "h1")
    sb.highlight("img#image1")  # A fancier assert_element() call
    sb.click('a:contains("This Page")')  # Use :contains() on any tag
    sb.click_link("Sign out")  # Link must be "a" tag. Not "button".
    sb.assert_element('a:contains("Sign in")')
    sb.assert_exact_text("You have been signed out!", "#top_message")

(See examples/raw_sb.py for the test.)

Here's another example, which uses test mode:

from seleniumbase import SB

with SB(test=True) as sb:
    sb.open("https://google.com/ncr")
    sb.type('[name="q"]', "SeleniumBase on GitHub\n")
    sb.click('a[href*="github.com/seleniumbase"]')
    sb.highlight("div.Layout-main")
    sb.highlight("div.Layout-sidebar")
    sb.sleep(0.5)

with SB(test=True, rtf=True, demo=True) as sb:
    sb.open("seleniumbase.github.io/demo_page")
    sb.type("#myTextInput", "This is Automated")
    sb.assert_text("This is Automated", "#myTextInput")
    sb.assert_text("This Text is Green", "#pText")
    sb.click('button:contains("Click Me")')
    sb.assert_text("This Text is Purple", "#pText")
    sb.click("#checkBox1")
    sb.assert_element_not_visible("div#drop2 img#logo")
    sb.drag_and_drop("img#logo", "div#drop2")
    sb.assert_element("div#drop2 img#logo")

(See examples/raw_test_scripts.py for the test.)

22. The driver manager (via context manager)

This pure Python format gives you a raw webdriver instance in a with block. The SeleniumBase Driver Manager will automatically make sure that your driver is compatible with your browser version. It gives you full access to customize driver options via method args or via the command-line. The driver will automatically call quit() after the code leaves the with block. Here are some examples:

"""Can run with "python". (pytest not needed)."""
from seleniumbase import DriverContext

with DriverContext() as driver:
    driver.get("https://seleniumbase.github.io/")
    driver.highlight('img[alt="SeleniumBase"]', loops=6)

with DriverContext(browser="chrome", incognito=True) as driver:
    driver.get("https://seleniumbase.io/apps/calculator")
    driver.click('[id="4"]')
    driver.click('[id="2"]')
    driver.assert_text("42", "#output")
    driver.highlight("#output", loops=6)

with DriverContext() as driver:
    driver.get("https://seleniumbase.github.io/demo_page")
    driver.highlight("h2")
    driver.type("#myTextInput", "Automation")
    driver.click("#checkBox1")
    driver.highlight("img", loops=6)

(See examples/raw_driver_context.py for an example.)

23. The driver manager (via direct import)

Another way of running Selenium tests with pure python (as opposed to using pytest or nosetests) is by using this format, which bypasses BaseCase methods while still giving you a flexible driver with a manager. SeleniumBase includes helper files such as page_actions.py, which may help you get around some of the limitations of bypassing BaseCase. Here's an example:

"""Driver() test. Runs with "python". (pytest not needed)."""
from seleniumbase import Driver

driver = Driver(browser="chrome", headless=False)
try:
    driver.get("https://seleniumbase.io/apps/calculator")
    driver.click('[id="4"]')
    driver.click('[id="2"]')
    driver.assert_text("42", "#output")
    driver.highlight("#output", loops=6)
finally:
    driver.quit()

driver = Driver()
try:
    driver.get("https://seleniumbase.github.io/demo_page")
    driver.highlight("h2")
    driver.type("#myTextInput", "Automation")
    driver.click("#checkBox1")
    driver.highlight("img", loops=6)
finally:
    driver.quit()

(From examples/raw_browser_launcher.py)

The above format can be used as a drop-in replacement for virtually every Python/selenium framework, as it uses the raw driver instance for handling commands. The Driver() method simplifies the work of managing drivers with optimal settings, and it can be configured via multiple method args. The Driver also accepts command-line options (such as python --headless) so that you don't need to modify your tests directly to use different settings. These command-line options only take effect if the associated method args remain unset (or set to None) for the specified options.

Open Source Automated Visual Testing

Michael Mintz — Sat, 05 Dec 2020 21:50:23 +0000

Automated Visual Regression Testing can help you detect when the layout of a web page has changed. Instead of comparing pixels from screenshots, layout differences can be detected by comparing HTML tags and attributes with a baseline. If a change is detected, it could mean that something broke, the web page was redesigned, or dynamic content changed.

(Watch the tutorial on YouTube ↘️)

To handle automated visual testing, SeleniumBase uses the self.check_window() method, which can set visual baselines for comparison and then compare the latest versions of web pages to the existing baseline.

The first time a test calls self.check_window() with a unique "name" parameter, the visual baseline is set, which means a folder is created with the following files:

page_url.txt -> The URL of the current window
screenshot.png -> A screenshot of the current window
tags_level1.txt -> HTML tags from the window
tags_level2.txt -> HTML tags + attribute names
tags_level3.txt -> HTML tags + attribute names+values

After the first time self.check_window() is called, later calls will compare the HTML tags and attributes of the latest window to the ones from the first call (or to the ones from the call when the baseline was last reset).

Here's an example call:

self.check_window(name="first_test)", level=3)

On the first run (or if the baseline is being set/reset) the "level" doesn't matter because that's only used for comparing the current layout to the existing baseline.

Here's how the level system works:

level=0 -> DRY RUN ONLY - Will perform a comparison to the baseline, and print out any differences that are found, but won't fail the test even if differences exist.
level=1 -> HTML tags are compared to tags_level1.txt
level=2 -> HTML tags and attribute names are compared to tags_level2.txt
level=3 -> HTML tags and attribute names+values are compared to tags_level3.txt

As shown, Level-3 is the most strict, Level-1 is the least strict. If the comparisons from the latest window to the existing baseline don't match, the current test will fail, except for Level-0 checks, which print Level-3 results without failing the test.

You can reset the visual baseline on the command line by adding the following parameter at runtime:
--visual_baseline

As long as --visual_baseline is used on the command line while running tests, the self.check_window() method cannot fail because it will rebuild the visual baseline rather than comparing the html tags of the latest run to the existing baseline. If there are any expected layout changes to a website that you're testing, you'll need to reset the baseline to prevent unnecessary failures.

self.check_window() will fail with "Page Domain Mismatch Failure" if the domain of the current URL doesn't match the domain of the baseline URL.

If you want to use self.check_window() to compare a web page to a later version of itself in the same test, add the baseline=True parameter to your first self.check_window() call to use that as the baseline. (This only makes sense if you're calling self.check_window() more than once with the same "name" parameter in the same test.)

Automated Visual Testing with self.check_window() is not very effective for websites that have dynamic content because that changes the layout and structure of web pages. For those pages, you're much better off using regular SeleniumBase functional testing, unless you can remove the dynamic content before performing the comparison, (such as by using self.ad_block() to remove dynamic ad content on a web page).

Example usage of self.check_window() with different levels:

    self.check_window(name="testing", level=0)
    self.check_window(name="xkcd_home", level=1)
    self.check_window(name="github_page", level=2)
    self.check_window(name="wikipedia_page", level=3)

    self.check_window(name="helloworld", baseline=True)
    ### Do something that may change the web page
    self.check_window(name="helloworld", level=3)

Here's an example where clicking a button makes a hidden element visible:

from seleniumbase import BaseCase

class VisualLayoutTest(BaseCase):

    def test_applitools_layout_change_failure(self):
        self.open('https://applitools.com/helloworld?diff1')
        print('\nCreating baseline in "visual_baseline" folder.')
        self.check_window(name="helloworld", baseline=True)
        # Click a button that changes the text of an element
        self.click('a[href="?diff1"]')
        # Click a button that makes a hidden element visible
        self.click("button")
        self.check_window(name="helloworld", level=3)

Here's the output of that: (Text changes do not impact visual comparisons)

AssertionError:
First differing element 39:
['div', [['class', ['section', 'hidden-section', 'image-section']]]]
['div', [['class', ['section', 'image-section']]]]

-  ['div', [['class', ['section', 'hidden-section', 'image-section']]]],
?                                ------------------
+  ['div', [['class', ['section', 'image-section']]]],
*
*** Exception: <Level 3> Visual Diff Failure:
* HTML tag attribute values don't match the baseline!

Here's an example where a button is removed from a web page:

from seleniumbase import BaseCase

class VisualLayoutTest(BaseCase):

    def test_python_home_layout_change_failure(self):
        self.open('https://python.org/')
        print('\nCreating baseline in "visual_baseline" folder.')
        self.check_window(name="python_home", baseline=True)
        # Remove the "Donate" button
        self.remove_element('a.donate-button')
        self.check_window(name="python_home", level=3)

Here's the output of that:

AssertionError:
First differing element 33:
['a', [['class', ['donate-button']], ['href', '/psf/donations/']]]
['div', [['class', ['options-bar']]]]

-  ['a', [['class', ['donate-button']], ['href', '/psf/donations/']]],
-     'display: list-item; opacity: 0.995722;']]],
?                         -------------------
+     'display: list-item;']]],
*
*** Exception: <Level 3> Visual Diff Failure:
* HTML tag attribute values don't match the baseline!

Here's an example where a web site logo is resized:

from seleniumbase import BaseCase

class VisualLayoutTest(BaseCase):

    def test_xkcd_layout_change_failure(self):
        self.open('https://xkcd.com/554/')
        print('\nCreating baseline in "visual_baseline" folder.')
        self.check_window(name="xkcd_554", baseline=True)
        # Change height: (83 -> 130) , Change width: (185 -> 120)
        self.set_attribute('[alt="xkcd.com logo"]', "height", "130")
        self.set_attribute('[alt="xkcd.com logo"]', "width", "120")
        self.check_window(name="xkcd_554", level=3)

Here's the output of that:

AssertionError:
First differing element 22:
['img[30 chars]['height', '83'], ['src', '/s/0b7742.png'], ['width', '185']]]
['img[30 chars]['height', '130'], ['src', '/s/0b7742.png'], ['width', '120']]]

-    ['height', '83'],
?                ^
+    ['height', '130'],
?                ^ +
-    ['width', '185']]],
?                ^^
+    ['width', '120']]],
?                ^^
*
*** Exception: <Level 3> Visual Diff Failure:
* HTML tag attribute values don't match the baseline!

To run the example (from examples/visual_testing/) with a pytest HTML Report, use:

pytest test_layout_fail.py --html=report.html

Here's what the pytest HTML Report looks like:

In conclusion, open source automated visual testing tools are being built directly into test frameworks, and this trend is growing. Just like many years ago when free Wi-Fi at coffee shops replaced Internet cafes that charged money for Internet access, open source tools for visual testing will replace their paid counterparts in time. You'll remember this next time you're sipping your Starbucks® Pumpkin Spice Latte with your free Internet access, instead of paying for Internet at cybercafes.

Original tutorial at: SeleniumBase.io => Visual Testing
YouTube link: SeleniumBase Visual Testing
Cover Photo: seleniumbase.io/devices/?url=github.com
SeleniumBase GitHub: github.com/seleniumbase/SeleniumBase

Bringing new life into Edge Selenium Tools

Michael Mintz — Thu, 03 Sep 2020 07:50:11 +0000

This year, Microsoft Edge is officially reborn (in Chromium form) with tools to automate it, such as: https://github.com/microsoft/edge-selenium-tools -> "An updated EdgeDriver implementation for Selenium 3". This includes three separate libraries with implementations for C#, JavaScript, and Python. The upcoming Selenium 4 will include these libraries automatically, with the latest stable version of Selenium being 3.141 right now.

After spending some quality time using the new Edge and running automated browser tests on it with the Python edge-selenium-tools, I can safely say that Edge can be used as a drop-in replacement for Chrome as needed for automated testing, with some small differences such as handling browser extensions. I'm also the creator of a test framework called SeleniumBase, which uses edge-selenium-tools and simplifies Edge automation by wrapping a complete framework around the APIs to enhance the automation experience.

(Above: GitHub -> SeleniumBase/examples/edge_test.py, which highlights key areas on the Edge "About" page.)

In order to make Edge automation work, you'll need EdgeDriver, which is normally obtained by going to https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/ and then downloading the version you need. Thankfully, SeleniumBase lets you install the latest stable version of EdgeDriver in seconds by running a simple command:

$ seleniumbase install edgedriver

*** edgedriver version for download = 85.0.564.44

Downloading edgedriver_mac64.zip from:
https://msedgedriver.azureedge.net/85.0.564.44/edgedriver_mac64.zip ...
Download Complete!

Extracting ['msedgedriver'] from edgedriver_mac64.zip ...
Unzip Complete!

The file [msedgedriver] was saved to:
/Users/michael/github/SeleniumBase/seleniumbase/drivers/msedgedriver

Making [msedgedriver 85.0.564.44] executable ...
[msedgedriver] is now ready for use!

Also convenient is the ability to set Edge options from the command line when running tests with SeleniumBase. For example, you can activate the built-in mobile-device emulator by simply running a test with --mobile:

(Above: GitHub -> SeleniumBase/examples/test_skype_site.py, which highlights key areas on Skype's mobile website.)

Including Edge as part of your test automation suite is more important than ever, especially since the marketshare of Edge is rapidly growing. If you're already using SeleniumBase, running a test with Edge is as easy as adding --browser=edge to your run command. This is one of the many ways that SeleniumBase expands on pytest command-line options. (For reference, pytest is a unit-testing framework that can run SeleniumBase scripts.)

In summary, the new Edge browser is ready for your automated tests, and SeleniumBase paired with edge-selenium-tools can help you get started quickly. Visit the GitHub page at https://github.com/seleniumbase/SeleniumBase to learn more. There are many example tests to guide you in the right direction, and those can be run with --browser=edge to use Edge instead of the default browser.

Special thanks to John Jansen (https://twitter.com/thejohnjansen) for answering my Edge automation questions on Twitter. And thank you to Mat Velloso (https://twitter.com/matvelloso) for the nice shout-out there.

(Above: Tweets to me by John Jansen and Mat Velloso)

About me: I'm Michael Mintz, currently the DevOps/Automation Lead at iboss, (a Microsoft "Trusted Security Partner"). In my spare time, I expand and maintain SeleniumBase (https://github.com/seleniumbase/SeleniumBase - https://seleniumbase.io/). Normally you'll find me around Boston, but I've been working from home for most of 2020. You can find me on Twitter: https://twitter.com/seleniumbase (and yes, I use that account far more frequently than my personal one).

(That's me on the right with the glasses and the hoodie.)

Pytest vs Cypress: A fair fight in UI testing?

Michael Mintz — Wed, 17 Jun 2020 04:22:59 +0000

Right now, we're witnessing the greatest disruption of the test automation industry that we've ever seen. New tools being developed, and existing tools are getting significant improvements. Today, let's talk about two major test frameworks that have lots of users according to GitHub:

Some of you may already be familiar with cypress: a known framework for end-to-end testing. Unlike cypress, pytest is mostly known as just being a unit-testing framework (for Python). Less known about pytest is that it has a major plugin ecosystem for expanding its abilities. Just like Batman has a tool belt for letting him do things that he can't do with his bare hands, pytest has plugins for allowing it to do much more, such as browser testing, multi-threading tests, and creating test reports. Before we can go into the pytest vs cypress comparison, let's talk about an essential component needed for UI testing with pytest, which is the selenium browser automation library.

In the past, you've probably heard of comparisons being done between cypress and selenium. This raw comparison might not have been fair because Selenium clearly states on their website: "Selenium automates browsers. That's it! What you do with that power is entirely up to you." (source: selenium.dev) Nowhere on their website did Selenium say anything such as them being "a complete test framework", etc. They specifically wanted to give developers and test automation engineers the ability to create their own test frameworks that use selenium. A more fair comparison would be cypress vs a test framework that uses selenium.

Fast-forward to today: Lots of companies want to get a lot of testing done very quickly, but they don't have the time they need to build a complete UI testing framework for their testing. This has led to a lot of corner-cutting (aka sloppy code), and false blame against perfectly solid automation libraries that work great when used properly. One thing to keep in mind when using raw Selenium methods is that if you try interacting with page elements that haven't fully loaded (or elements that haven't been re-found after a page reload), then you may see errors like this:

NoSuchElementException
ElementNotVisibleException
MoveTargetOutOfBoundsException
StaleElementReferenceException
ElementNotInteractableException

These errors are completely preventable if your test framework wraps selenium methods with the appropriate code that smart-waits for page elements to be fully interactable before interacting with them (or timeout/fail the test if the element still doesn't appear after a set number of seconds). The good news is that a test framework with selenium smart-waiting already exists as a pytest plugin: SeleniumBase!

SeleniumBase bridges the gap between pytest and selenium for UI testing. With pytest, you have a unit-testing framework without a built-in web automation component. With selenium, you have a web automation library without a built-in test framework. Both sides of the bridge have long been very popular and very powerful, but now there's a special bridge that seamlessly brings the two sides together in one very powerful, but simple, package. And this package, SeleniumBase, exists as a pytest plugin, which uses the selenium library effectively.

Here's an example SeleniumBase test:



from seleniumbase import BaseCase

class MyTestClass(BaseCase):
    def test_basic(self):
        self.open("https://store.xkcd.com/search")
        self.type('input[name="q"]', "xkcd book\n")
        self.assert_text("xkcd: volume 0", "h3")
        self.open("https://xkcd.com/353/")
        self.assert_title("xkcd: Python")
        self.assert_element('img[alt="Python"]')
        self.click('a[rel="license"]')
        self.assert_text("free to copy and reuse")
        self.go_back()
        self.click_link_text("About")
        self.assert_exact_text("xkcd.com", "h2")

That test is from the latest version of SeleniumBase/examples/my_first_test.py, which you can run using pytest:



pytest my_first_test.py

As you can see, it's very easy to open a URL, type text, click, and assert various elements on a page. For a more advanced example (with hovering dropdowns, iFrames, select options, sliders, finding broken links, and detecting JavaScript errors), see SeleniumBase/examples/test_demo_site.py

Now let's compare that with a Cypress example:



describe('My First Test', () => {
  it('Gets, types and asserts', () => {
    cy.visit('https://example.cypress.io')
    cy.contains('type').click()
    cy.url().should('include', '/commands/actions')
    cy.get('.action-email')
      .type('fake@email.com')
      .should('have.value', 'fake@email.com')
  })
})

Aside from the obvious differences that Cypress tests are written in JavaScript, and SeleniumBase tests are written in Python, you'll see that both examples are written using simple code, both examples are easy to run, and both examples run reliably.

For test reports:

cypress has the Cypress Dashboard Service.
pytest has the pytest-html plugin, which SeleniumBase modifies to include screenshots of failing tests at the moment they failed:

SeleniumBase doesn't have its own dashboard service, but you can easily run your SeleniumBase tests from any cloud service you desire. For open-source projects, I've personally used three free tools: First Travis-CI, then Azure Pipelines, and finally GitHub Actions, which allows you to keep all your work and test results in GitHub. Here's an example of SeleniumBase results from GitHub Actions:

When using SeleniumBase to test applications that aren't open source, I've primarily used Jenkins. If you're doing test automation on a tight budget for closed-source projects, the most cost-effective Jenkins solution I've found so far is Google Cloud's $13.61 USD/month Bitnami Jenkins instance, which supports unlimited users and unlimited test runs (limited only by its CPU, which is enough to handle five simultaneous browser tests without any noticeable lag). As for Cypress tests, those can also be run with GitHub Actions and on Jenkins.

Now that we've covered the basics, lets move onto limitations when it comes to Cypress vs Pytest. Cypress actually has a page on its website dedicated to its limitations, aka "trade-offs": docs.cypress.io -> trade-offs.html.

These Cypress limitations include:

Limited iFrame support.
No multiple tabs.
No multiple browsers at the same time.
Each test is bound to a single origin domain.
Missing mobile support.
Not a general purpose automation tool.

With pytest and SeleniumBase, all of the following features exist:

Full iFrame support.
Open as many tabs as you want in tests.
Open as many browsers as you want in tests.
No limitations on multi-origin domain navigation.
Uses Chrome's mobile-device emulator for mobile tests.
Can be used for general purpose automation.

The only limitation with SeleniumBase is that you must use Python! (And for Python users that's not a limitation... that's a feature!) The good news is that: You can also make JavaScript calls with SeleniumBase!
This is done with:



self.execute_script(JAVASCRIPT)

This ability to execute JavaScript inside SeleniumBase Python scripts has led to some powerful new features, such as the website tour builder that's part of SeleniumBase (learn more about the SeleniumBase tour-builder here):

As for SeleniumBase's mobile mode, just add:
--mobile to the pytest run command of any SeleniumBase test to run it using Chrome's mobile device emulator:

The fastest way to get started with SeleniumBase is by cloning it from GitHub so that you can run all the included example tests, but you can also install seleniumbase from PyPI with pip, then do:
seleniumbase mkdir TEST_FOLDER to create a folder anywhere that includes example tests for you to run.

At the time this article was published, the latest version of seleniumbase was "v1.40.2", so if you're using an older version of SeleniumBase, some of the features mentioned here might not exist until you upgrade.

Here are some links to material discussed in this article:

Now that you've had a chance to look at both Cypress and Pytest (with the SeleniumBase plugin), you must decide for yourself where to go from here. I'm biased of course (being a Python developer). I started learning Python in 2008 at a company called ITA Software, which was later acquired by Google. And I started learning Selenium in 2011 at a company called HubSpot, which funded the creation of the test framework that I would later rename to SeleniumBase in 2014 after the project got approval to be open-sourced. (Trivia: I decided on the name "SeleniumBase" on the day Google acquired Firebase. I heard about that acquisition on the news, and I liked the sound of "Firebase", so I took that idea and added "Base" onto "Selenium", and that became the name of the framework ever since.)

I hope that you got a few key takeaways from this article: Mainly, that when used correctly, Selenium is awesome for UI testing. When paired together with pytest (and a good "bridge" like SeleniumBase), Selenium is even more awesome. People have spent a lot of time unjustly trying to replace Selenium, when in reality, all they needed to do was replace their implementation strategy.

Thank you to both the pytest and Selenium teams for all the hard work you've done in making great testing tools. Here's a shout-out to some of the major contributors of these projects: Simon Stewart, Bruno Oliveira, Jim Evans, Ronny Pfannschmidt, David Burns, Florian Bruhin, Dave Hunt, Jason Huggins, Diego Molina, and many more key contributors that I haven't listed here. There will always be competition in the test automation space, but together, we can continue to create a legacy for test automation engineers of today and the future.

Using Python to load JavaScript packages into any website

Michael Mintz — Mon, 25 May 2020 08:55:00 +0000

SeleniumBase lets you load JavaScript packages from any CDN link into any website.

Here's an example of loading a website-tour library into the browser while visiting Google:

This example, (google_tour.py from the SeleniumBase examples/tour_examples/ folder), can be run with pytest after you've cloned and installed SeleniumBase from GitHub:

pytest google_tour.py

Since a CDN is used for holding packages, you no longer need to use other package managers such as NPM, Bower, or Yarn.

Here's the Python code for loading JS packages into the web browser with SeleniumBase:

self.add_js_link(js_link)

This example loads the IntroJS JavaScript library:

self.add_js_link("https://cdnjs.cloudflare.com/ajax/libs/intro.js/2.9.3/intro.min.js")

You can load any JS package this way as long as you know the URL.

If you're wondering how SeleniumBase does this, here's the full Python code, which uses WebDriver's execute_script() method for making JS calls after escaping quotes:

def add_js_link(driver, js_link):
    script_to_add_js = (
        """function injectJS(link) {
              var body = document.getElementsByTagName("body")[0];
              var script = document.createElement("script");
              script.src = link;
              script.defer;
              script.type="text/javascript";
              script.crossorigin = "anonymous";
              script.onload = function() { null };
              body.appendChild(script);
           }
           injectJS("%s");""")
    js_link = escape_quotes_if_needed(js_link)
    driver.execute_script(script_to_add_js % js_link)

Now that you've loaded JavaScript into the browser, you may also want to load some CSS to go along with it:

self.add_css_link(css_link)

Here's code that loads the IntroJS CSS:

self.add_css_link("https://cdnjs.cloudflare.com/ajax/libs/intro.js/2.9.3/introjs.css")

And here's the Python WebDriver code that makes this possible:

def add_css_link(driver, css_link):
    script_to_add_css = (
        """function injectCSS(css) {
              var head = document.getElementsByTagName("head")[0];
              var link = document.createElement("link");
              link.rel = "stylesheet";
              link.type = "text/css";
              link.href = css;
              link.crossorigin = "anonymous";
              head.appendChild(link);
           }
           injectCSS("%s");""")
    css_link = escape_quotes_if_needed(css_link)
    driver.execute_script(script_to_add_css % css_link)

Website tours are just one of the many ways of using the SeleniumBase JS Package Manager.

The following example shows the JqueryConfirm package loaded into a website for creating fancy dialog boxes:

(Example from SeleniumBase's MasterQA ReadMe)
Since packages are loaded directly from a CDN, such as CloudFlare's cdnjs, there's no need to use NPM, Bower, Yarn, or other package managers to get the packages that you need into the websites that you want. To learn more about SeleniumBase, check out the Docs Site: SeleniumBase.io All the code is on GitHub: SeleniumBase on GitHub

And if you're just interested in creating website tours with SeleniumBase, here's the link to the Website Tours ReadMe.

Running browser tests from GitHub Actions with SeleniumBase

Michael Mintz — Wed, 22 Apr 2020 07:29:03 +0000

The SeleniumBase Python-WebDriver framework allows you easily automate Web UI tests quickly and reliably. Here's an example of this test running against a website to test the complete flow of logging in, searching for an item, adding the item to a shopping cart, and making a purchase:

That test was run with pytest, a Python unit-testing framework that can expand to do much more than unit-testing. The --demo command-line option was added to activate "Demo Mode", which slows down the test and lets you see what the test assertions are. (Run from here).

pytest test_swag_labs.py --demo

Once you've created your tests, you can easily run them from GitHub Workflows. This tutorial will help you get started.

Step 0. Create a fork of SeleniumBase on GitHub to help you get started.

(You'll be using your own repo eventually.)

Step 1. From the GitHub Actions tab, choose to set up a Python package Workflow.

Step 2. Add your workflow `.yml` script.

(If using a SeleniumBase fork, the script from https://github.com/seleniumbase/SeleniumBase/blob/master/.github/workflows/python-package.yml already exists to help guide you.)

Step 3. Commit your changes to GitHub.

Step 4. Your tests will now run on every pull request and on every commit to the `master` branch.

(See https://github.com/seleniumbase/SeleniumBase/actions for the SeleniumBase example.)

(You can click inside each build for more details.)

(You can also see the specific steps being performed by each command.)

(You'll notice that web browsers such as Chrome and Firefox get installed for tests to use. SeleniumBase uses pytest for running tests while using Selenium WebDriver to interact with web browsers.)

Step 5. Congratulations! You now know how to create and run browser tests with GitHub Workflows!

Study SeleniumBase to learn more!

Getting Started with SeleniumBase for Test Automation

Michael Mintz — Mon, 11 Nov 2019 07:04:35 +0000

You might not have heard of SeleniumBase, but you've likely heard a lot about Selenium! The common misconception is that Selenium is a complete standalone test automation framework. Not true, even according to the official website, which says: {"Selenium automates browsers. That's it!"}. That's where SeleniumBase comes in.

SeleniumBase carefully combines the powers of Selenium into Python's pytest unit testing framework, which provides customizable command line arguments and plugins for HTML reports, multi-threading, test-ordering, retrying failures, parameterization, and more. Unlike pytest-selenium (which is a very primitive merger of pytest and Selenium), SeleniumBase also does the following:

Contains reliable, smart-waiting code to prevent flaky tests.
Simplifies the process of creating UI tests for any website.
Includes Plugins for logging test results and screenshots.
Includes powerful methods such as assert_no_404_errors()
Includes command-line options such as --proxy=SERVER:PORT
Includes tools for assisted QA and website tours.
... and so much more.

Here's an example of a test running in Demo Mode, which lets you see test actions as they occur:

(Above: my_first_test.py from examples/ in Demo Mode.)

from seleniumbase import BaseCase


class MyTestClass(BaseCase):

    def test_basic(self):
        self.open("https://store.xkcd.com/search")
        self.type('input[name="q"]', "xkcd book")
        self.click('input[value="Search"]')
        self.assert_text("xkcd: volume 0", "h3")
        self.open("https://xkcd.com/353/")
        self.assert_title("xkcd: Python")
        self.assert_element('img[alt="Python"]')
        self.click('a[rel="license"]')
        self.assert_text("free to copy and reuse")
        self.go_back()
        self.click_link_text("About")
        self.assert_exact_text("xkcd.com", "h2")
        self.click_link_text("geohashing")
        self.assert_element("#comic img")

pytest my_first_test.py --demo

Here's a more advanced example, which demonstrates logging in, adding items to a shopping cart, and making a purchase:

(Above: test_swag_labs.py from examples/ in Demo Mode.)

from seleniumbase import BaseCase


class SwagLabsTests(BaseCase):

    def login_to_swag_labs(self, username="standard_user"):
        """ Login to Swag Labs and verify success. """
        self.open("https://www.saucedemo.com/")
        if username not in self.get_text("#login_credentials"):
            self.fail("Invalid user for login: %s" % username)
        self.type("#user-name", username)
        self.type("#password", "secret_sauce")
        self.click('input[type="submit"]')
        self.assert_element("#inventory_container")
        self.assert_text("Products", "div.product_label")

    def test_swag_labs_basic_flow(self):
        """ This test checks functional flow of the Swag Labs store. """
        self.login_to_swag_labs(username="standard_user")

        # Verify that the "Test.allTheThings() T-Shirt" appears on the page
        item_name = "Test.allTheThings() T-Shirt"
        self.assert_text(item_name)

        # Verify that a reverse-alphabetical sort works as expected
        self.select_option_by_value("select.product_sort_container", "za")
        if item_name not in self.get_text("div.inventory_item"):
            self.fail('Sort Failed! Expecting "%s" on top!' % item_name)

        # Add the "Test.allTheThings() T-Shirt" to the cart
        self.assert_exact_text("ADD TO CART", "button.btn_inventory")
        item_price = self.get_text("div.inventory_item_price")
        self.click("button.btn_inventory")
        self.assert_exact_text("REMOVE", "button.btn_inventory")
        self.assert_exact_text("1", "span.shopping_cart_badge")

        # Verify your cart
        self.click("#shopping_cart_container path")
        self.assert_exact_text("Your Cart", "div.subheader")
        self.assert_text(item_name, "div.inventory_item_name")
        self.assert_exact_text("1", "div.cart_quantity")
        self.assert_exact_text("REMOVE", "button.cart_button")
        continue_shopping_button = "link=CONTINUE SHOPPING"
        if self.browser == "safari":
            # Safari sees this element differently
            continue_shopping_button = "link=Continue Shopping"
        self.assert_element(continue_shopping_button)

        # Checkout - Add info
        self.click("link=CHECKOUT")
        self.assert_exact_text("Checkout: Your Information", "div.subheader")
        self.assert_element("a.cart_cancel_link")
        self.type("#first-name", "SeleniumBase")
        self.type("#last-name", "Rocks")
        self.type("#postal-code", "01720")

        # Checkout - Overview
        self.click("input.btn_primary")
        self.assert_exact_text("Checkout: Overview", "div.subheader")
        self.assert_element("link=CANCEL")
        self.assert_text(item_name, "div.inventory_item_name")
        self.assert_text(item_price, "div.inventory_item_price")
        self.assert_exact_text("1", "div.summary_quantity")

        # Finish Checkout and verify item is no longer in cart
        self.click("link=FINISH")
        self.assert_exact_text("THANK YOU FOR YOUR ORDER", "h2")
        self.assert_element("img.pony_express")
        self.click("#shopping_cart_container path")
        self.assert_element_absent("div.inventory_item_name")
        self.click(continue_shopping_button)
        self.assert_element_absent("span.shopping_cart_badge")

cd examples
pytest test_swag_labs.py --demo

With SeleniumBase, methods such as click() and type() will automatically wait for website pages to be fully loaded before taking action on elements, which prevents flaky tests. This means you won't need to use random time.sleep() statements in tests anymore.

SeleniumBase can also create website tours by generating JavaScript out of a few lines of Python:

from seleniumbase import BaseCase


class MyTourClass(BaseCase):

    def test_google_tour(self):
        self.open('https://google.com/ncr')
        self.wait_for_element('input[title="Search"]')

        # Create a website tour using the ShepherdJS library with "dark" theme
        # Same as:  self.create_shepherd_tour(theme="dark")
        self.create_tour(theme="dark")
        self.add_tour_step("Welcome to Google!", title="SeleniumBase Tours")
        self.add_tour_step("Type in your query here.", 'input[title="Search"]')
        self.play_tour()

        self.highlight_update_text('input[title="Search"]', "Google")
        self.wait_for_element('[role="listbox"]')  # Wait for autocomplete

        # Create a website tour using the ShepherdJS library with "light" theme
        # Same as:  self.create_shepherd_tour(theme="light")
        self.create_tour(theme="light")
        self.add_tour_step("Then click to search.", '[value="Google Search"]')
        self.add_tour_step("Or press [ENTER] after entry.", '[title="Search"]')
        self.play_tour()

        self.highlight_update_text('input[title="Search"]', "GitHub\n")
        self.wait_for_element("#search")

        # Create a website tour using the Bootstrap Tour JS library
        # Same as:  self.create_bootstrap_tour()
        self.create_tour(theme="bootstrap")
        self.add_tour_step("See results here!", title="(autoplay in 5s)")
        self.add_tour_step("Here's the next tour:")
        self.play_tour(interval=5)  # Tour automatically continues after 5 sec

        self.open("https://www.google.com/maps/@42.3598616,-71.0912631,15z")
        self.wait_for_element("#searchboxinput")
        self.wait_for_element("#minimap")
        self.wait_for_element("#zoom")

        # Create a website tour using the IntroJS library
        # Same as:  self.create_introjs_tour()
        self.create_tour(theme="introjs")
        self.add_tour_step("Welcome to Google Maps!")
        self.add_tour_step("Type in a location here.",
                           "#searchboxinput", title="Search Box")
        self.add_tour_step("Then click here to show it on the map.",
                           "#searchbox-searchbutton", alignment="bottom")
        self.add_tour_step("Or click here to get driving directions.",
                           "#searchbox-directions", alignment="bottom")
        self.add_tour_step("Use this button to switch to Satellite view.",
                           "#minimap div.widget-minimap", alignment="right")
        self.add_tour_step("Click here to zoom in.",
                           "#widget-zoom-in", alignment="left")
        self.add_tour_step("Or click here to zoom out.",
                           "#widget-zoom-out", alignment="left")
        self.add_tour_step("Use the Menu button to see more options.",
                           ".searchbox-hamburger-container", alignment="right")
        self.add_tour_step("Or click here to see more Google apps.",
                           '[title="Google apps"]', alignment="left")
        self.add_tour_step("Thanks for using SeleniumBase Tours!",
                           title="End of Guided Tour")
        self.export_tour()  # The default name for exports is "my_tour.js"
        self.play_tour()

cd examples/tour_examples
pytest google_tour.py

This is just the beginning of the #LowCode movement, which is all about using a few lines of code to do the work of many lines of code.

SeleniumBase installation is easy, and it only takes a few minutes to start running your first test. Check out the framework on GitHub, which contains lots of documentation and dozens of examples to help you get started. https://github.com/seleniumbase/SeleniumBase