Building Targets is tedious... so lets automate that....

[bandophahita]

I created a custom action to automatically generate the targets on a page or even within a section of a page.

Usage:

def test_building_new_test(actor: Actor):
    # you'll need to get to the page first.. 
    actor.will(GetToThePageThatNeedsTargets())  
    # Don't forget about timing!  The page needs to load properly before the action will be useful
    actor.will(FindAllIds()

    # it even has the ability to look only inside a specific tag.
    actor.will(FindAllIds("div", {"id" : "somevalue"}))

Sample output:
(yeah, google.com has some goofy ids)

GB = Target("gb").located(
    By.id('gb')
)
    

GBWA = Target("gbwa").located(
    By.id('gbwa')
)
    

SPCH_DLG = Target("spch-dlg").located(
    By.id('spch-dlg')
)

from __future__ import annotations

from typing import Any

from bs4 import BeautifulSoup, Tag
from screenpy import Actor, Answerable, Performable
from screenpy_selenium.abilities import BrowseTheWeb


def print_ids(ids: list[str]) -> None:
    for i in ids:
        s = f"""
{i.upper().replace("-", "_")} = Target("{i}").located(
    By.id('{i}')
)
    """
        print(s)


def print_dtis(dtis: list[str]) -> None:
    for dti in dtis:
        s = f"""
{dti.upper().replace("-", "_")} = Target("{dti}").located(
    By.dti('{dti}')
)
    """
        print(s)


class GetSoup(Answerable):
    def answered_by(self, actor: Actor) -> BeautifulSoup:
        driver = actor.ability_to(BrowseTheWeb).browser
        return BeautifulSoup(driver.page_source, "html.parser")


def list_attrs(soup: Tag, attribute: str = "id") -> list[str]:
    tags = soup.find_all(attrs={attribute: True})
    atrs: list[str] = []
    for tag in tags:
        value = tag.get(attribute)
        if value:
            atrs.append(value)
    return atrs


class _Base(Performable):
    @classmethod
    def from_(cls: type[_Base], *args: Any, **kwargs: Any) -> _Base:
        return cls(*args, **kwargs)

    @classmethod
    def from_content(cls: type[_Base]) -> _Base:
        return cls("div", "main-content")

    @classmethod
    def from_sidenav(cls: type[_Base]) -> _Base:
        return cls("div", "main-side-nav")

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        self.args = args
        self.kwargs = kwargs


class FindAllIds(_Base):
    """
    Usage:

    FindAllIds.from_content()

    FindAllIds("tag", {"attribute_name": "attribute"})
    FindAllIds("div", {"data-testid" : "somevalue"})
    FindAllIds("div", {"id" : "somevalue"})
    """

    def perform_as(self, actor: Actor) -> None:
        soup = GetSoup().answered_by(actor)
        if self.args or self.kwargs:
            soup = soup.find(*self.args, **self.kwargs)

        ids = list_attrs(soup, "id")

        msg = "ALL IDS"
        if self.args or self.kwargs:
            msg = f"ALL IDS from {self.args} {self.kwargs}"
        print(msg)
        print_ids(ids)
        return


class FindAllTestIds(_Base):
    def perform_as(self, actor: Actor) -> None:
        soup = GetSoup().answered_by(actor)
        if self.args or self.kwargs:
            soup = soup.find(*self.args, **self.kwargs)

        ids = list_attrs(soup, "data-testid")

        msg = "ALL TEST IDS"
        if self.args or self.kwargs:
            msg = f"ALL TEST IDS from {self.args} {self.kwargs}"
        print(msg)
        print_dtis(ids)
        return

[bandophahita]

You'll notice I use a custom By in my example. You could just convert back to the normal selenium version or you can use this:

from __future__ import annotations

import re

from selenium.webdriver.common.by import By as _By

T = tuple[str, str]


class By(_By):
    @staticmethod
    def cls(s: str) -> T:
        return By.css(f".{s}")

    @staticmethod
    def css(s: str) -> T:
        return (By.CSS_SELECTOR, s)

    @staticmethod
    def css_attr(s: str, attrib: str) -> T:
        return By.css(f'[{attrib}="{s}"]')

    @staticmethod
    def dti(s: str) -> T:
        return By.css_attr(s, "data-testid")

    @staticmethod
    def id(s: str) -> T:  # noqa: A003
        return (By.ID, s)

    @staticmethod
    def name(s: str) -> T:
        return By.css_attr(s, "name")

    @staticmethod
    def tag(s: str) -> T:
        return (By.TAG_NAME, s)

    @staticmethod
    def xpath(s: str) -> T:
        return (By.XPATH, s)


def escape_css_selector(s: str) -> str:
    return re.sub(r"([!\"#$%&'()*+,\-./:;<=>?@\[\\\]^`{|}~])", r"\\\g<1>", s)

[perrygoy]

I love that you turned it into a Performable so an Actor could do it, rather than just a straight script.

Personally, i tend to view the sum total of Targets in my project as something that should change as the scripts change—only things that are actually being used by a test should be in there. But i recognize that's not everyone's opinion, and definitely having a script like this would make updating your Targets much much easier.

It's almost similar to automated API schema generation or something, it's neat! If your dev team is consistent with their IDs, maybe you could have a pre-test chore where your Actor goes to each page and updates the Target files for the tests to use... i wonder if that would work.

[bandophahita]

I, too, keep my targets separate from the test modules. When I built this it quickly became apparent that not all target names made sense. Sometimes it was the IDs, sometimes it was the var names. So it made sense to me to print to the screen and figure out what to do with them as needed. The output needs to be tailored according to need.