def append_failure(self, report):
"""Append xml report with failed TC.
Args:
report(dict): Failure report
"""
self.class_logger.info("Appending XML report with fail.")
report['sections'] = [
xml_unescape(section) for section in report['sections']
] # pylint: disable=no-member
sec = dict(report['sections'])
self.fail_traceback = self.Junit.failure(message="Test failure") # pylint: disable=no-member
# Removing BASH escape symbols (decolorizing)
# longrepr = xml_unescape(re_sub(r"\x1b.*?m", "", report['longrepr']))
longrepr = xml_unescape(report['longrepr'])
# TODO: Change str to encode for unicode text
try:
self.fail_traceback.append(str(longrepr))
except UnicodeEncodeError as err:
self.fail_traceback.append(ud.normalize('NFKD', longrepr))
self.class_logger.warning("Unicode data in traceback: %s" %
(err, ))
self.append(self.fail_traceback)
for name in ("out", "err"):
content = sec.get("Captured std{0}".format(name))
if content:
tag = getattr(self.Junit, "system-{0}".format(name))
self.append(tag(content))
self.failed += 1
def loadXML(self):
if not os_path.exists(self.filename):
return
def getValue(definitions, default):
ret = ""
Len = len(definitions)
return Len > 0 and definitions[Len - 1].text or default
try:
tree = ci_parse(self.filename).getroot()
self.read_services = []
self.read_providers = []
self.usingcaid = []
self.ci_config = []
for slot in tree.findall("slot"):
read_slot = getValue(slot.findall("id"), False).encode("UTF-8")
print "ci " + read_slot
i = 0
for caid in slot.findall("caid"):
read_caid = caid.get("id").encode("UTF-8")
self.selectedcaid.append(
(str(read_caid), str(read_caid), i))
self.usingcaid.append(long(read_caid, 16))
i += 1
for service in slot.findall("service"):
read_service_ref = xml_unescape(
service.get("ref").encode("UTF-8"))
self.read_services.append(read_service_ref)
for provider in slot.findall("provider"):
read_provider_name = xml_unescape(
provider.get("name").encode("UTF-8"))
read_provider_dvbname = xml_unescape(
provider.get("dvbnamespace").encode("UTF-8"))
self.read_providers.append(
(read_provider_name, read_provider_dvbname))
self.ci_config.append(
(int(read_slot), (self.read_services, self.read_providers,
self.usingcaid)))
except:
print "[CI_Config_CI%d] error parsing xml..." % self.ci_slot
for item in self.read_services:
if len(item):
self.finishedChannelSelection(item)
for item in self.read_providers:
if len(item):
self.finishedProviderSelection(item[0], item[1])
print self.ci_config
self.finishedCAidSelection(self.selectedcaid)
self["ServiceList"].l.setList(self.servicelist)
self.setServiceListInfo()
def loadXML(self):
if not os_path.exists(self.filename):
return
def getValue(definitions, default):
Len = len(definitions)
return Len > 0 and definitions[Len-1].text or default
try:
tree = ci_parse(self.filename).getroot()
self.read_services=[]
self.read_providers=[]
self.usingcaid=[]
self.ci_config=[]
for slot in tree.findall("slot"):
read_slot = getValue(slot.findall("id"), False).encode("UTF-8")
print "ci " + read_slot
i=0
for caid in slot.findall("caid"):
read_caid = caid.get("id").encode("UTF-8")
self.selectedcaid.append((str(read_caid),str(read_caid),i))
self.usingcaid.append(long(read_caid,16))
i+=1
for service in slot.findall("service"):
read_service_ref = xml_unescape( service.get("ref").encode("UTF-8") )
self.read_services.append (read_service_ref)
for provider in slot.findall("provider"):
read_provider_name = xml_unescape( provider.get("name").encode("UTF-8") )
read_provider_dvbname = xml_unescape( provider.get("dvbnamespace").encode("UTF-8") )
self.read_providers.append((read_provider_name,read_provider_dvbname))
self.ci_config.append((int(read_slot), (self.read_services, self.read_providers, self.usingcaid)))
except:
print "[CI_Config_CI%d] error parsing xml..." %self.ci_slot
for item in self.read_services:
if len(item):
self.finishedChannelSelection(item)
for item in self.read_providers:
if len(item):
self.finishedProviderSelection(item[0],item[1])
print self.ci_config
self.finishedCAidSelection(self.selectedcaid)
self["ServiceList"].l.setList(self.servicelist)
self.setServiceListInfo()
def _parse_menu_tag(self, item):
name = None
untranslated_name = None
query = None
icon = None
only_unallocated = False
dont_display = False
flags = []
subcategories = []
sortmode = SortMethods.BY_ALPHABET
item_limit = 0
for element in item.getchildren():
# ignore inline translations, we use gettext for this
if (element.tag == "Name"
and '{http://www.w3.org/XML/1998/namespace}lang'
in element.attrib):
continue
if element.tag == "Name":
untranslated_name = element.text
# gettext/xml writes stuff from software-center.menu
# out into the pot as escaped xml, so we need to escape
# the name first, get the translation and unscape it again
escaped_name = xml_escape(untranslated_name)
name = xml_unescape(gettext.gettext(escaped_name))
elif element.tag == "SCIcon":
icon = element.text
elif element.tag == 'Flags':
flags = self._parse_flags_tag(element)
elif element.tag == "Directory":
l = self._parse_directory_tag(element)
if l:
(untranslated_name, name, gettext_domain, icon) = l
elif element.tag == "Include":
query = self._parse_include_tag(element)
elif element.tag == "OnlyUnallocated":
only_unallocated = True
elif element.tag == "SCDontDisplay":
dont_display = True
elif element.tag == "SCSortMode":
sortmode = int(element.text)
if not self._verify_supported_sort_mode(sortmode):
return None
elif element.tag == "SCItemLimit":
item_limit = int(element.text)
elif element.tag == "Menu":
subcat = self._parse_menu_tag(element)
if subcat:
subcategories.append(subcat)
else:
LOG.warn("UNHANDLED tag in _parse_menu_tag: %s" % element.tag)
if untranslated_name and query:
return Category(untranslated_name, name, icon, query,
only_unallocated, dont_display, flags,
subcategories, sortmode, item_limit)
else:
LOG.warn("UNHANDLED entry: %s %s %s %s" %
(name, untranslated_name, icon, query))
return None
def _parse_menu_tag(self, item):
name = None
untranslated_name = None
query = None
icon = None
only_unallocated = False
dont_display = False
flags = []
subcategories = []
sortmode = SortMethods.BY_ALPHABET
item_limit = 0
for element in item.getchildren():
# ignore inline translations, we use gettext for this
if (element.tag == "Name" and
'{http://www.w3.org/XML/1998/namespace}lang' in element.attrib):
continue
if element.tag == "Name":
untranslated_name = element.text
# gettext/xml writes stuff from software-center.menu
# out into the pot as escaped xml, so we need to escape
# the name first, get the translation and unscape it again
escaped_name = xml_escape(untranslated_name)
name = xml_unescape(gettext.gettext(escaped_name))
elif element.tag == "SCIcon":
icon = element.text
elif element.tag == 'Flags':
flags = self._parse_flags_tag(element)
elif element.tag == "Directory":
l = self._parse_directory_tag(element)
if l:
(untranslated_name, name, gettext_domain, icon) = l
elif element.tag == "Include":
query = self._parse_include_tag(element)
elif element.tag == "OnlyUnallocated":
only_unallocated = True
elif element.tag == "SCDontDisplay":
dont_display = True
elif element.tag == "SCSortMode":
sortmode = int(element.text)
if not self._verify_supported_sort_mode(sortmode):
return None
elif element.tag == "SCItemLimit":
item_limit = int(element.text)
elif element.tag == "Menu":
subcat = self._parse_menu_tag(element)
if subcat:
subcategories.append(subcat)
else:
LOG.warn("UNHANDLED tag in _parse_menu_tag: %s" % element.tag)
if untranslated_name and query:
return Category(untranslated_name, name, icon, query, only_unallocated, dont_display, flags, subcategories, sortmode, item_limit)
else:
LOG.warn("UNHANDLED entry: %s %s %s %s" % (name,
untranslated_name,
icon,
query))
return None
def text_xmldecode(data):
"""
XML decode to unicode text.
:param str data: Data to decode to unicode.
:return: XML decoded data.
:rtype: str
"""
return xml_unescape(data)
def text_xmldecode(data):
'''
XML decode to unicode text.
:param str data: Data to decode to unicode.
:return: XML decoded data.
:rtype: str
'''
return xml_unescape(data)
def _unescape(self, s):
""" Unescape entities for easy editing """
return xml_unescape(s, {
'"': '"',
''': "'",
'%': '%',
''': "'",
'%': '%',
''': "'",
})
def _unescape(self, s):
""" Unescape entities for easy editing """
return xml_unescape(
s, {
'"': '"',
''': "'",
'%': '%',
''': "'",
'%': '%',
''': "'",
})
def append_xfail(self, report):
"""Append xml report with xfailed TC.
Args:
report(dict): XFail report
"""
self.class_logger.info("Appending XML report with xfail.")
self.append(
self.Junit.skipped(
str(xml_unescape(report['keywords']['xfail'])), # pylint: disable=no-member
message="expected test failure"))
def fetch_with_refresh(url, accept_encodings=HTTP_ENCODINGS, max_delay=20, user_agent_spoof=None):
try:
hops = []
refresh = True
while refresh is not None:
headers = {'accept-encoding': ', '.join(accept_encodings or HTTP_ENCODINGS)}
if user_agent_spoof is not None:
headers['User-Agent'] = USER_AGENTS[user_agent_spoof]
try:
response = requests.get(url, timeout=10, headers=headers)
except requests.exceptions.ContentDecodingError as e:
enc = re.search('Received response with content-encoding: ([a-z]+),', repr(e))
if not enc:
raise
enc = enc.group(1)
if enc not in accept_encodings:
raise
print('>> Removing encoding {!r} for {!r}'.format(enc, url.encode('utf8')), file=sys.stderr)
try:
accept_encodings.remove(enc)
except AttributeError:
pass
continue
hops.extend(response.history)
hops.append(response)
if response.status_code >= 400:
break
refresh = response.headers.get('refresh')
if refresh is None:
match = meta_refresh_re.search(response.content)
if match is not None:
tag = match.group(0).lower()
if 'http-equiv="refresh' in tag \
or 'http-equiv=\'refresh' in tag:
refresh = match.group(1)
if refresh is not None and refresh != response.url:
delay, next_url = refresh.split(';', 1)
_, next_url = next_url.split('=', 1)
next_url = urlparse.urljoin(url, xml_unescape(next_url))
assert next_url.startswith('http')
if next_url in (hop.url for hop in hops):
break
url = next_url
if int(delay) > max_delay:
refresh = None
except Exception as e:
raise FetchException(e, url, hops)
if hops[-1].status_code == 200 and not hops[-1].content:
raise FetchException('Status 200 but empty content', url, hops, code=-2)
return hops
def add_torrents(self):
(model, row) = self.listview_torrents.get_selection().get_selected()
if row is not None:
self.save_torrent_options(row)
torrents_to_add = []
row = self.torrent_liststore.get_iter_first()
while row is not None:
torrent_id = self.torrent_liststore.get_value(row, 0)
filename = xml_unescape(
decode_bytes(self.torrent_liststore.get_value(row, 2)))
try:
options = self.options[torrent_id]
except KeyError:
options = None
file_priorities = self.get_file_priorities(torrent_id)
if options is not None:
options['file_priorities'] = file_priorities
if self.infos[torrent_id]:
torrents_to_add.append((
os.path.split(filename)[-1],
b64encode(self.infos[torrent_id]),
options,
))
elif is_magnet(filename):
client.core.add_torrent_magnet(filename,
options).addErrback(log.debug)
row = self.torrent_liststore.iter_next(row)
def on_torrents_added(errors):
if errors:
log.info(
'Failed to add %d out of %d torrents.',
len(errors),
len(torrents_to_add),
)
for e in errors:
log.info('Torrent add failed: %s', e)
else:
log.info('Successfully added %d torrents.',
len(torrents_to_add))
if torrents_to_add:
client.core.add_torrent_files(torrents_to_add).addCallback(
on_torrents_added)
def unescape(obj: Any) -> str:
"""Unescape xml entities.
Parameters
----------
obj : Any
Can be anything that will be converted to string, then where xml entities will be unescaped.
Returns
-------
str
The unescaped string version of `obj`.
"""
return xml_unescape(str(obj), UNESCAPE_CHARS)
def append_skipped(self, report):
"""Append xml reports with skipped TC.
Args:
report(dict): Skipped report
"""
self.class_logger.info("Appending XML report with skip.")
# filename, lineno, skipreason = report['longrepr']
# self.class_logger.debug("Received longrepr: {0}".format(xml_unescape(report['longrepr'])))
longrepr = xml_unescape(report['longrepr'])
# TODO: fixed bug with longrepr crashing
skipreason = get_skipped_reason(report['longrepr'])
self.append(
self.Junit.skipped(
"%s" % longrepr, # pylint: disable=no-member
type="pytest.skip",
message=skipreason))
# self.append(self.Junit.skipped("%s:%s: %s" % longrepr, type="pytest.skip", message=skipreason))
self.skipped += 1
def _parse_menu_tag(self, item):
name = None
untranslated_name = None
query = None
icon = None
only_unallocated = False
dont_display = False
subcategories = []
for element in item.getchildren():
# ignore inline translations, we use gettext for this
if element.tag == "Name" and "{http://www.w3.org/XML/1998/namespace}lang" in element.attrib:
continue
if element.tag == "Name":
untranslated_name = element.text
# gettext/xml writes stuff from software-center.menu
# out into the pot as escaped xml, so we need to escape
# the name first, get the translation and unscape it again
escaped_name = xml_escape(untranslated_name)
name = xml_unescape(gettext.gettext(escaped_name))
elif element.tag == "SCIcon":
icon = element.text
elif element.tag == "Directory":
(untranslated_name, name, gettext_domain, icon) = self._parse_directory_tag(element)
elif element.tag == "Include":
query = self._parse_include_tag(element)
elif element.tag == "OnlyUnallocated":
only_unallocated = True
elif element.tag == "SCDontDisplay":
dont_display = True
elif element.tag == "Menu":
subcat = self._parse_menu_tag(element)
if subcat:
subcategories.append(subcat)
else:
print "UNHANDLED tag in _parse_menu_tag: ", element.tag
if untranslated_name and query:
return Category(untranslated_name, name, icon, query, only_unallocated, dont_display, subcategories)
else:
print "UNHANDLED entry: ", name, untranslated_name, icon, query
return None
def append_error(self, report, when=""):
"""Append xml report with error (in case TC failed on setup or teardown).
Args:
report(dict): Error report
when(str): Error occurance stage (setup|call|teardown)
"""
self.class_logger.info("Appending XML report with error.")
if 'longrepr' in list(report.keys()):
longrepr = xml_unescape(report['longrepr'])
if self.fail_traceback is not None:
failure_reason = None
if len(self.tests[-1]) > 0:
failure_reason = self.tests[-1].pop()
if self.update is not None and len(self.tests[-1]) > 0:
self.tests[-1].pop()
try:
self.tests[-1].pop()
except IndexError:
pass
self.append(
self.Junit.error(
longrepr, # pylint: disable=no-member
message="Test error on %s and Test failure" %
(when, )))
if hasattr(
failure_reason.attr, "message"
) and failure_reason.attr.message == "Failure Reason":
self.tests[-1].append(failure_reason)
self.tests[-1][0].extend("\n" + "-" * 80 +
"\nTest Case Failure\n" + "-" * 80 +
"\n")
self.tests[-1][0].extend(self.fail_traceback)
else:
self.append(
self.Junit.error(
longrepr, # pylint: disable=no-member
message="Test error on %s" % (when, )))
self.errors += 1
self.failed += 1
def add_torrents(self):
(model, row) = self.listview_torrents.get_selection().get_selected()
if row is not None:
self.save_torrent_options(row)
torrents_to_add = []
row = self.torrent_liststore.get_iter_first()
while row is not None:
torrent_id = self.torrent_liststore.get_value(row, 0)
filename = xml_unescape(self.torrent_liststore.get_value(row, 2))
try:
options = self.options[torrent_id]
except KeyError:
options = None
file_priorities = self.get_file_priorities(torrent_id)
if options is not None:
options['file_priorities'] = file_priorities
if deluge.common.is_magnet(filename):
del options['file_priorities']
client.core.add_torrent_magnet(filename, options)
else:
torrents_to_add.append((os.path.split(filename)[-1],
base64.encodestring(self.infos[torrent_id]),
options))
row = self.torrent_liststore.iter_next(row)
def on_torrents_added(errors):
if errors:
log.info('Failed to add %d out of %d torrents.', len(errors), len(torrents_to_add))
for e in errors:
log.info('Torrent add failed: %s', e)
else:
log.info('Successfully added %d torrents.', len(torrents_to_add))
client.core.add_torrent_files(torrents_to_add).addCallback(on_torrents_added)
def decode(self, content, response):
return xml_unescape(content)
def _unescape(self, s):
return xml_unescape(s, {"'": "'", '"': '"'})
def _unescape(self, s):
return xml_unescape(s, {"'": "'", '"': '"'})
def unescape(text):
return xml_unescape(text, html_unescape_table)
