def _normalize_selector(self):
if len(self.wd_locators) > 1:
raise LocatorException('Can not locate element with {}'.format(
self.wd_locators))
if self._merge_scope:
self.selector['scope'] = self.query_scope.selector_builder.built
if 'class' in self.selector or 'class_name' in self.selector:
classes = [self.selector.get('class')]
classes.extend([self.selector.pop('class_name', None)])
classes = list(_ for _ in ClassHelpers._flatten(classes)
if _ is not None)
for class_name in classes:
if isinstance(
class_name,
tuple(STRING_TYPES)) and ' ' in class_name.strip():
self._deprecate_class_list(class_name)
self.selector['class'] = classes
if self.selector.get(
'adjacent') == 'ancestor' and 'text' in self.selector:
raise LocatorException(
'Can not find parent element with text locator')
for key in self.selector.copy():
self._check_type(key, self.selector.get(key))
how, what = self._normalize_locator(key,
self.selector.pop(key, None))
self.selector[how] = what
def locate_all(self, built):
self.built = copy(built)
self.driver_scope = self._locator_scope.wd
self.filter = 'all'
if 'index' in self.built:
raise ValueError("can't locate all elements by 'index'")
return list(ClassHelpers._flatten(self._matching_elements))
def check_match(how, expected):
if how == 'tag_name':
return self._validate_tag(element, expected)
elif how in ['class', 'class_name']:
value = self._fetch_value(element, how)
return all(any(self._matches_values(class_value, match) for class_value
in value.split()) for match in ClassHelpers._flatten([expected]))
else:
return self._matches_values(self._fetch_value(element, how), expected)
def _attribute_string(self):
attributes = []
for key in self.selector.copy():
attribute = self._process_attribute(key, self.selector.pop(key))
if attribute is not None:
attributes.append(attribute)
attributes = list(ClassHelpers._flatten(attributes))
return '[{}]'.format(
' and '.join(attributes)) if len(attributes) > 0 else ''
def _matching_elements(self):
if len(self.built) == 1 and self.filter == 'first':
return self._locate_element(
*list(ClassHelpers._flatten(self.built.items())))
retries = 0
while retries <= 2:
try:
locator = list(ClassHelpers._flatten(self._wd_locator.items()))
elements = self._locate_elements(*locator)
return self.element_matcher.match(elements, self._match_values,
self.filter)
except StaleElementReferenceException:
retries += 1
sleep(0.5)
pass
target = 'element collection' if self.filter == 'all' else 'element'
raise LocatorException('Unable to locate {} from {} due to changing '
'page'.format(target, self.selector))
def _class_string(self):
from nerodia.locators.class_helpers import ClassHelpers
class_name = self.selector.pop('class', None)
if class_name is None:
return ''
self.built['class'] = []
predicates = []
for value in ClassHelpers._flatten([class_name]):
pred = self._process_attribute('class', value)
if pred is not None:
predicates.append(pred)
if len(self.built['class']) == 0:
self.built.pop('class')
if len(predicates) > 0:
return '[{}]'.format(' and '.join(predicates))
else:
return ''
def _class_string(self):
from nerodia.locators.class_helpers import ClassHelpers
class_name = self.selector.pop('class', None)
if class_name is None:
return ''
if isinstance(class_name, str) and ' ' in class_name.strip():
self._deprecate_class_list(class_name)
self.requires_matches['class'] = []
predicates = []
for value in ClassHelpers._flatten([class_name]):
pred = self._process_attribute('class', value)
if pred is not None:
predicates.append(pred)
if len(self.requires_matches['class']) == 0:
self.requires_matches.pop('class')
if len(predicates) > 0:
return '[{}]'.format(' and '.join(predicates))
else:
return ''
def _check_type(self, how, what):
if how in ['class', 'class_name']:
for c in list(ClassHelpers._flatten([what])):
self._raise_unless(c, self.VALID_WHATS[how])
else:
self._raise_unless(what, self.VALID_WHATS[how])