Conditions prévues de sélénium - possible d'utiliser 'ou'?

Je suis en utilisant le Sélénium 2 /WebDriver avec l'API Python, comme suit:

from selenium.webdriver.support import expected_conditions as EC

# code that causes an ajax query to be run

WebDriverWait(driver, 10).until( EC.presence_of_element_located( \
    (By.CSS_SELECTOR, "div.some_result")));

Je veux attendre pour soit un résultat retourné (div.some_result) ou un "not found" de la chaîne. Est-ce possible? Genre:

WebDriverWait(driver, 10).until( \
    EC.presence_of_element_located( \
         (By.CSS_SELECTOR, "div.some_result")) \
    or 
    EC.presence_of_element_located( \
         (By.CSS_SELECTOR, "div.no_result")) \
);

Je me rends compte que je pouvais le faire avec un sélecteur CSS (div.no_result, div.some_result), mais est-il un moyen de le faire en utilisant le Sélénium conditions prévues méthode?

source d'informationauteur artfulrobot

  1. 13

    J'ai fait comme ceci:

    class AnyEc:
    """ Use with WebDriverWait to combine expected_conditions
        in an OR.
    """
    def __init__(self, *args):
        self.ecs = args
    def __call__(self, driver):
        for fn in self.ecs:
            try:
                if fn(driver): return True
            except:
                pass

    Puis l'appeler comme...

    from selenium.webdriver.support import expected_conditions as EC
# ...
WebDriverWait(driver, 10).until( AnyEc(
    EC.presence_of_element_located(
         (By.CSS_SELECTOR, "div.some_result")),
    EC.presence_of_element_located(
         (By.CSS_SELECTOR, "div.no_result")) ))

    Évidemment, il serait trivial de mettre également en œuvre un AllEc classe de la même manière.

    Nb. le try: bloc est impair. J'étais confus parce que certains ECs retourner true/false tandis que d'autres vont lancer des exceptions pour de Faux. Les Exceptions sont capturés par des WebDriverWait donc mon AnyEc chose a été de produire des résultats bizarres parce que le premier à lancer une exception signifiait AnyEc ne pas procéder à l'essai suivant.

  2. 1

    Question très ancienne, mais,

    Examiner comment WedDriverWait travaux, dans un exemple indépendants de sélénium:

    def is_even(n):
    return n % 2 == 0

x = 10

WebDriverWait(x, 5).until(is_even)

    Cela permettra d'attendre jusqu'à 5 secondes pour is_even(x) de retour True

    maintenant, WebDriverWait(7, 5).until(is_even) prendra 5 secondes et de lever un TimeoutException

    S'avère, vous pouvez retourner n'importe quel non Falsy valeur et le capturer:

    def return_if_even(n):
    if n % 2 == 0:
        return n
    else:
        return False

x = 10
y = WebDriverWait(x, 5).until(return_if_even)
print(y) # >> 10

    Maintenant examiner la manière dont les méthodes de EC travaux:

    print(By.CSS_SELECTOR) # first note this is only a string
>> 'css selector'

cond = EC.presence_of_element_located( ('css selector', 'div.some_result') )
# this is only a function(*ish), and you can call it right away:

cond(driver)
# if element is in page, returns the element, raise an exception otherwise

    Probablement, vous voulez essayer quelque chose comme:

    def presence_of_any_element_located(parent, *selectors):
    ecs = []
    for selector in selectors:
        ecs.append(
            EC.presence_of_element_located( ('css selector', selector) )
        )

     # Execute the 'EC' functions agains 'parent'
     ecs = [ec(parent) for ec in ecs]

     return any(ecs)

    cela fonctionnerait si EC.presence_of_element_located retourné False quand selector pas trouvé dans parentmais il soulève une exception, une facile-à-comprendre la solution de contournement serait:

    def element_in_parent(parent, selector):
    matches = parent.find_elements_by_css_selector(selector)
    if len(matches) == 0:
        return False
    else:
        return matches

def any_element_in_parent(parent, *selectors):
    for sel in selectors:
        matches = element_in_parent(parent, selector)
        # if there is a match, return right away
        if matches:
            return matches
    # If list was exhausted
    return False

# let's try 
any_element_in_parent(driver, 'div.some_result', 'div.no_result')
# if found in driver, will return matches, else, return False

# For convenience, let's make a version wich takes a tuple containing the arguments:
cond = lambda args: any_element_in_parent(*args)
cond( (driver, 'div.some_result', 'div.no_result') )
# exactly same result as above

# At last, wait up until 5 seconds for it 
WebDriverWait((driver, 'div.some_result', 'div.no_result'), 5).until(cond)

    Mon but était d'expliquer, artfulrobot déjà donné un extrait de code pour un usage général de réels EC méthodes, il suffit de noter que

    class A(object):
    def __init__(...): pass
    def __call__(...): pass

    Est juste un moyen plus souple de définir des fonctions (en fait, une "fonction", mais c'est sans importance dans ce contexte)

  3. -2

    Essayez d'utiliser l'expression lambda:

    WebDriverWait(driver, 10).until(lambda a:

    a.presence_of_element_located(By.CSS_SELECTOR, "div.some_result") OR
    a.presence_of_element_located(By.CSS_SELECTOR, "div.no_result"))