def to_xml(self): """Return an XML instance of the suite""" x = XMLBuilder('testsuite', name=self.name, tests=str(self.ntests), errors=str(self.nerrors), failures=str(self.nfailure), skip=str(self.nskipped)) for test_case in self.tests: classname = test_case.classname # sanitize for XML text = "" if test_case.text is None else test_case.text etype = "" if test_case.etype is None else test_case.etype with x.testcase(classname=classname, name=test_case.name, result=test_case.result, etype=etype, text=text): if test_case.result == 'failures': x.error(type=test_case.etype, message=test_case.message) elif test_case.result == 'failure': x.failure(type=test_case.etype, message=test_case.message) elif test_case.result == 'skipped': x.skipped(type=test_case.etype, message=test_case.message) elif test_case.result == 'error': x.error(type=test_case.etype, message=test_case.message) else: # Successful testcase pass return x
def makeXML(cls, name, memory, vcpu, *devices): if cls.domain_type is None: raise libvirt.libvirtError("%r can't be instanciated - no domain type" \ % cls) cfg = DomainConfig(name, memory, vcpu, devices) root = XMLBuilder('domain', type=cls.domain_type) cls.commonFields(root, cfg) with root.os: cls.generateOS(root, cfg) root.clock(sync='localtime') cls.powerFeatures(root, cfg) with root.devices: cls.emulator(root, cfg) for dev in devices: dev.toxml(root) cls.commonDevices(root, cfg) return root
def checkstyle_xml(diags_set): def converted_severity(fauxpas_severity): # checkstyle severities: ignore, info, warning, error if (9 <= fauxpas_severity): return 'error' elif (5 <= fauxpas_severity): return 'warning' return 'info' x = XMLBuilder('checkstyle') diags_by_file = diags_set.grouped_diagnostics(by_property='file') for filepath, diags in diags_by_file.items(): with x.file(name=filepath or diags_set.pbxproj_path): for diag in diags: message = diag.info if 0 < len(message): message += ' ' message += '(%s - %s)' % (diag.ruleName, diag.ruleDescription) x.error(severity=converted_severity(diag.severity), source=diag.ruleShortName, message=message, line=str(diag.extent.start.line), column=str(diag.extent.start.utf16Column) ) return str(x)
def _generate_xml(self, exception,message = ""): _,_,trace = sys.exc_info() xml = XMLBuilder() tb_dict = {} tb = traceback.extract_tb(trace) with xml.notice(version = 2.0): xml << ('api-key', self.environment.api_key) with xml.notifier: xml << ('name', self.environment.name) xml << ('version', self.environment.version) xml << ('url', self.environment.url) with xml('server-environment'): xml << ('environment-name', self.environment.environment_name) with xml.error: xml << ('class', exception.__class__.__name__) if message == "": xml << ('message', str(exception)) else: xml << ('message', str(exception) + '\n\n' + message) with xml.backtrace: for trace in tb: tb_dict['filename'] = trace[0] tb_dict['line_number'] = trace[1] tb_dict['function_name'] = trace[2] xml << ('line', { 'file':tb_dict.get('filename', 'unknown'), 'number':tb_dict.get('line_number', 'unknown'), 'method':tb_dict.get('function_name', 'unknown') }) return str(xml)
def pipeline_to_xml(p): """ Convert a Pipeline to XML :type p: Pipeline :param p: :return: """ root = XMLBuilder(Constants.WORKFLOW_TEMPLATE_ROOT, id=p.idx) with getattr(root, Constants.ENTRY_POINTS): for eid, bid in p.entry_bindings: _d = {"id": eid, "in": bid} getattr(root, Constants.ENTRY_POINT)(**_d) with getattr(root, Constants.BINDINGS): for bout, bin_ in p.bindings: _d = {"out": bout, "in": bin_} getattr(root, Constants.BINDING)(**_d) # Engine level Options # for completeness write this element getattr(root, "options") # Task Options with getattr(root, "task-options"): for key, value in p.task_options.iteritems(): _d = {"id": key} with getattr(root, 'option')(**_d): root.value(str(value)) return root
def get_user_auth(self, f): x = XMLBuilder('QUERIES') with x.QUERY(cmd='REGISTER'): x.CLIENT(self.CLIENT_ID_TAG) response = self.query_eyeq(x) self.USER = response['USER'] self.config.USER = self.USER save_config(f, self.config)
def testWith(self): xml = XMLBuilder() with xml.root(lenght = 12): pass self.assertEqual(str(xml),'<root lenght="12" />') xml = XMLBuilder() with xml.root(): xml << "text1" << "text2" << ('some_node',) self.assertEqual(str(xml),"<root>text1text2<some_node /></root>")
def build_snapshot_xml(self, name=None, description=None): """ :rtype : String :type name: String :type description: String """ xml_builder = XMLBuilder('domainsnapshot') if not (name is None): xml_builder.name(name) if not (description is None): xml_builder.description(description) return str(xml_builder)
def tree_to_xml(root): xml = XMLBuilder('map', version='0.9.0') def rec_tree(tree, xnode): if tree == {}: return xnode['folded'] = 'true' for key, subtree in tree.iteritems(): rec_tree(subtree, xnode.node(text=key)) xroot = xml.node(text='Categories') rec_tree(root, xroot) xroot['folded'] = 'false' return str(xml)
def testFormat(self): x = XMLBuilder('utf-8',format = True) with x.root(): x << ('array',) with x.array(len = 10): with x.el(val = 0): pass with x.el('xyz',val = 1): pass x << ("el","abc",{'val':2}) << ('el',dict(val=3)) x << ('el',dict(val=4)) << ('el',dict(val='5')) with x('sup-el',val = 23): x << "test " self.assertEqual(str(x),result1)
def pacbio_options_to_xml(option_type_name, task_options_d): """Option type name is the task-option or option""" warnings.warn("JSON is the recommended format. XML writing will removed", DeprecationWarning) x = XMLBuilder(Constants.WORKFLOW_TEMPLATE_PRESET_ROOT) # Need to do this getattr to get around how the API works with getattr(x, option_type_name): for option_id, value in task_options_d.iteritems(): if value is not None: with x.option(id=option_id): x.value(str(value)) return x
def schema_options_to_xml(option_type_name, schema_options_d): """Option type name is the task-option or option""" x = XMLBuilder(Constants.WORKFLOW_TEMPLATE_PRESET_ROOT) # Need to do this getattr to get around how the API works with getattr(x, option_type_name): for option_id, schema in schema_options_d.iteritems(): default_value = schema['properties'][option_id]['default'] if default_value is not None: with x.option(id=option_id): default_value = schema['properties'][option_id]['default'] x.value(str(default_value)) return x
def schema_options_to_xml(option_type_name, schema_options_d): """Option type name is the task-option or option""" x = XMLBuilder(Constants.WORKFLOW_TEMPLATE_PRESET_ROOT) # Need to do this getattr to get around how the API works with getattr(x, option_type_name): for option_id, schema in schema_options_d.iteritems(): default_value = schema["properties"][option_id]["default"] if default_value is not None: with x.option(id=option_id): default_value = schema["properties"][option_id]["default"] x.value(str(default_value)) return x
def sso_token(subscription_id, cloud_service_name, resource_type, resource_name): signature = "%s:%s:%s:%s" % (subscription_id, cloud_service_name, resource_name, sso_secret) token = hashlib.sha1(signature) timestamp = str(datetime.now()) x = XMLBuilder('SsoToken', xmlns='http://schemas.microsoft.com/windowsazure') x.TimeStamp(timestamp) x.Token(str(token.hexdigest())) response_string = str(x) app.logger.debug(response_string) return Response(response_string, status=200, mimetype='text/xml')
def toxml(self, hrn = None): xml = XMLBuilder(format = True, tab_step = " ") with xml.RSpec(type="VINI"): if hrn: element = xml.network(name="Public_VINI", slice=hrn) else: element = xml.network(name="Public_VINI") with element: for site in self.getSites(): site.toxml(xml, hrn, self.nodes) for link in self.sitelinks: link.toxml(xml) header = '<?xml version="1.0"?>\n' return header + str(xml)
def make_story_xml(self, name=None, description=None, story_type=None, owned_by=None, requested_by=None, estimate=None, current_state=None, labels=None): story = XMLBuilder('story') if name is not None: story.name << name if description is not None: story.description << description if requested_by is not None: story.requested_by << requested_by if owned_by is not None: story.owned_by << owned_by if story_type is not None: story.story_type << story_type if estimate is not None: story.estimate << str(estimate) if current_state is not None: story.current_state << current_state if labels is not None: label_string = ',' if labels: label_string = ','.join(labels) story.labels << label_string return str(story)
def _build_retrieve_request(self, fields, uids): x = XMLBuilder('request', xmlns='http://www.isinet.com/xrpc42') with x.fn(name='LinksAMR.retrieve'): with x.list: x.map with x.map: with x.list(name='WOS'): for field in fields: x.val(field) with x.map: for i, uid in enumerate(uids): with x.map(name='cite{}'.format(i)): x.val(uid, name='ut') return str(x)
def testShift(self): xml = (XMLBuilder() << ('root', )) self.assertEqual(str(xml), "<root />") xml = XMLBuilder() xml << ('root', "some text") self.assertEqual(str(xml), "<root>some text</root>") xml = XMLBuilder() xml << ('root', {'x': 1, 'y': '2'}) self.assert_( xmlStructureEqual(str(xml), "<root x='1' y='2'>some text</root>")) xml = XMLBuilder() xml << ('root', {'x': 1, 'y': '2'}) self.assert_(xmlStructureEqual(str(xml), "<root x='1' y='2'></root>")) xml = XMLBuilder() xml << ('root', {'x': 1, 'y': '2'}) self.assert_( not xmlStructureEqual(str(xml), "<root x='2' y='2'></root>")) xml = XMLBuilder() xml << ('root', "gonduras.ua", {'x': 1, 'y': '2'}) self.assert_( xmlStructureEqual(str(xml), "<root x='1' y='2'>gonduras.ua</root>")) xml = XMLBuilder() xml << ('root', "gonduras.ua", {'x': 1, 'y': '2'}) self.assert_( xmlStructureEqual(str(xml), "<root x='1' y='2'>gonduras.com</root>"))
def scan(self): """Scans an spdx file by making good use of spdx_scanner.py file; then outputs the results in xml format.""" spdx_file = self.spdx_file spdx_scan_result = local( 'python -s spdx_scanner.py -s 10571 {spdx_file}'.format( spdx_file=spdx_file), capture=True) self.scan_results = XMLBuilder('spdx_file') with self.scan_results.data: for line in spdx_scan_result.splitlines(): single_line = line.split(',') with self.scan_results.item: self.scan_results.file(val=single_line[0]) self.scan_results.license_info(val=single_line[1]) self.scan_results.license_concluded(val=single_line[2]) etree_node = ~self.scan_results # print(str(self.scan_results)) return str(self.scan_results)
def toxml(self): xml = XMLBuilder(format = True, tab_step = " ") with xml.RSpec(type=self.type): if self.slice: element = xml.network(name=self.api.hrn, slice=self.slice.hrn) else: element = xml.network(name=self.api.hrn) with element: if self.slice: self.slice.toxml(xml) for site in self.getSites(): site.toxml(xml) for link in self.sitelinks: link.toxml(xml) header = '<?xml version="1.0"?>\n' return header + str(xml)
def make_post_xml(self, name, iteration_length, point_scale): project = XMLBuilder('project') if name is not None: project.name << name if iteration_length is not None: project.iteration_length << iteration_length if point_scale is not None: project.point_scale << point_scale return str(project)
def build_xml(spdx_scan_result): x = XMLBuilder('spdx_file') with x.data: for line in spdx_scan_result.splitlines(): single_line = line.split(',') with x.item: x.file(val=single_line[0]) x.license_info(val=single_line[1]) x.license_concluded(val=single_line[2]) etree_node = ~x return x
def make_post_xml(self, name, iteration_length, point_scale): project = XMLBuilder(format=True) with project.project: if name is not None: project << ('name', name) if iteration_length is not None: project << ('iteration_length', iteration_length) if point_scale is not None: project << ('point_scale', point_scale) return str(project)
def toxml(self): """ Produce XML directly from the topology specification. """ xml = XMLBuilder(format = True, tab_step = " ") with xml.RSpec(type=self.type): if self.slice: element = xml.network(name=self.api.hrn, slice=self.slice.hrn) else: element = xml.network(name=self.api.hrn) with element: if self.slice: self.slice.toxml(xml) for site in self.getSites(): site.toxml(xml) header = '<?xml version="1.0"?>\n' return header + str(xml)
def export_to_xml(people, questions_to_export, user_id, can_view_email): response = HttpResponse(content_type = "application/xml") response['Content-Disposition'] = 'attachment; filename="sc4g-people.xml"' xml = XMLBuilder('volunteers') for person in people: with xml.volunteer: xml.firstName(person.user.first_name) xml.lastName(person.user.last_name) if (can_view_email): xml.email(person.user.email) with xml.form_responses: for key, value in get_card_fields_with_icons_together(person, user_id).items(): xml.form_response(value, question=key) response.content = str(xml) return response
def create_snapshot(self, domain, snapshot_name, \ snapshot_description): """Create VM snapshot connection: object with a connection to the Hypervisor domain: VM name snapshot_name snapshot_description """ try: libvirt_domain = self.libvirt_connection.lookupByName(domain) xml_base = XMLBuilder('domainsnapshot') xml_base.name(snapshot_name) xml_base.description(snapshot_description) xml = str(xml_base) libvirt_domain.snapshotCreateXML(xml) except: print 'Unable to create snapshot' sys.exit(1) print 'Snapshot has been created successfully.'
def _generate_xml(self, exception): _,_,trace = sys.exc_info() xml = XMLBuilder() with xml.notice(version = 2.0): xml << ('api-key', self.environment.api_key) with xml.notifier: xml << ('name', self.environment.name) xml << ('version', self.environment.version) xml << ('url', self.environment.url) with xml('server-environment'): xml << ('environment-name', self.environment.environment_name) with xml.error: xml << ('class', exception.__class__.__name__) xml << ('message', str(exception)) with xml.backtrace: [xml << ('line', {'file':filename, 'number':line_number, 'method':function_name}) \ for filename, line_number, function_name, _ in traceback.extract_tb(trace)] return str(xml)
def xml_for_create_resource(region="West US", promotion_code=None, intrinsic_settings=None, etag=None, plan="Free"): if not etag: etag = str(uuid.uuid1()) headers = [('Content-Type', 'application/xml')] x = XMLBuilder('Resource', xmlns='http://schemas.microsoft.com/windowsazure') with x.CloudServiceSettings: x.GeoRegion(region) x.ETag(etag) x.IntrinsicSettings(intrinsic_settings) x.PromotionCode(promotion_code) x.Plan(plan) x.SchemaVersion("1.0") x.Type("cloudkeys") x.Version("1.0") return str(x)
def __query_xml(self): x = XMLBuilder('QUERIES') with x.AUTH: x.CLIENT(self.CLIENT_ID_TAG) x.USER(self.USER) x.COUNTRY(self.COUNTRY) x.LANG(self.LANG) return x
def _generate_xml(self, exception, additional_information=None): _,_,trace = sys.exc_info() xml = XMLBuilder() tb_dict = {} tb = traceback.extract_tb(trace) if tb: tb = tb[0] tb_dict['filename'] = tb[0] tb_dict['line_number'] = tb[1] tb_dict['function_name'] = tb[2] message = str(exception) if additional_information: message = 'error: %s, additional info: %s' % (message, additional_information) with xml.notice(version = 2.0): xml << ('api-key', self.api_key) with xml.notifier: xml << ('name', self.name) xml << ('version', self.version) xml << ('url', self.url) with xml('server-environment'): xml << ('environment-name', self.environment_name) with xml.error: xml << ('class', exception.__class__.__name__) xml << ('message', message) with xml.backtrace: xml << ('line', { 'file':tb_dict.get('filename', 'unknown'), 'number':tb_dict.get('line_number', 'unknown'), 'method':tb_dict.get('function_name', 'unknown') }) return str(xml)
def checkstyle_xml(diags_set): def converted_severity(fauxpas_severity): # checkstyle severities: ignore, info, warning, error if (9 <= fauxpas_severity): return 'error' elif (5 <= fauxpas_severity): return 'warning' return 'info' x = XMLBuilder('checkstyle') diags_by_file = diags_set.grouped_diagnostics(by_property='file') for filepath, diags in diags_by_file.items(): with x.file(name=filepath or diags_set.pbxproj_path): for diag in diags: message = diag.info if 0 < len(message): message += ' ' message += '(%s - %s)' % (diag.ruleName, diag.ruleDescription) x.error(severity=converted_severity(diag.severity), source=diag.ruleShortName, message=message, line=str(diag.extent.start.line), column=str(diag.extent.start.utf16Column)) return str(x)
def testWith(self): xml = XMLBuilder() with xml.root(lenght=12): pass self.assertEqual(str(xml), '<root lenght="12" />') xml = XMLBuilder() with xml.root(): xml << "text1" << "text2" << ('some_node', ) self.assertEqual(str(xml), "<root>text1text2<some_node /></root>")
def pipeline_to_xml(p): """ Convert a Pipeline to XML :type p: Pipeline :param p: :return: """ root = XMLBuilder(Constants.WORKFLOW_TEMPLATE_ROOT, id=p.idx) with getattr(root, Constants.ENTRY_POINTS): for eid, bid in p.entry_bindings: _d = {"id": eid, "in": bid} getattr(root, Constants.ENTRY_POINT)(**_d) with getattr(root, Constants.BINDINGS): for bout, bin_ in p.bindings: _d = {"out": bout, "in": bin_} getattr(root, Constants.BINDING)(**_d) return root
def testFormat(self): x = XMLBuilder('utf-8', format=True) with x.root(): x << ('array', ) with x.array(len=10): with x.el(val=0): pass with x.el('xyz', val=1): pass x << ("el", "abc", {'val': 2}) << ('el', dict(val=3)) x << ('el', dict(val=4)) << ('el', dict(val='5')) with x('sup-el', val=23): x << "test " self.assertEqual(str(x), result1)
def build_volume_xml(self, volume): """ :type volume: Volume :rtype : String """ volume_xml = XMLBuilder('volume') volume_xml.name( self._get_name( volume.environment and volume.environment.name or '', volume.name)) volume_xml.capacity(str(volume.capacity)) with volume_xml.target: volume_xml.format(type=volume.format) if volume.backing_store is not None: with volume_xml.backingStore: volume_xml.path(self.driver.volume_path(volume.backing_store)) volume_xml.format(type=volume.backing_store.format) return str(volume_xml)
def build_node_xml(self, node, emulator): """ :rtype : String :type node: Node """ node_xml = XMLBuilder("domain", type=node.hypervisor) node_xml.name( self._get_name(node.environment and node.environment.name or '', node.name)) with node_xml.cpu(mode='host-model'): node_xml.model(fallback='forbid') node_xml.vcpu(str(node.vcpu)) node_xml.memory(str(node.memory * 1024), unit='KiB') with node_xml.os: node_xml.type(node.os_type, arch=node.architecture) for boot_dev in json.loads(node.boot): node_xml.boot(dev=boot_dev) with node_xml.devices: node_xml.emulator(emulator) if node.has_vnc: if node.vnc_password: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes', passwd=node.vnc_password) else: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes') for disk_device in node.disk_devices: self._build_disk_device(node_xml, disk_device) for interface in node.interfaces: self._build_interface_device(node_xml, interface) with node_xml.video: node_xml.model(type='vga', vram='9216', heads='1') with node_xml.serial(type='pty'): node_xml.target(port='0') with node_xml.console(type='pty'): node_xml.target(type='serial', port='0') return str(node_xml)
def build_network_xml(self, network): """ :type network: Network :rtype : String """ network_xml = XMLBuilder('network') network_xml.name( self._get_name( network.environment and network.environment.name or '', network.name)) network_xml.bridge(name="dobr{0}".format(network.id), stp="on", delay="0") if not (network.forward is None): network_xml.forward(mode=network.forward) if not (network.ip_network is None): ip_network = IPNetwork(network.ip_network) with network_xml.ip(address=str(ip_network[1]), prefix=str(ip_network.prefixlen)): if network.has_pxe_server: network_xml.tftp(root=network.tftp_root_dir) if network.has_dhcp_server: with network_xml.dhcp: network_xml.range(start=str(network.ip_pool_start), end=str(network.ip_pool_end)) for interface in network.interfaces: for address in interface.addresses: if IPAddress(address.ip_address) in ip_network: network_xml.host( mac=str(interface.mac_address), ip=str(address.ip_address), name=interface.node.name) if network.has_pxe_server: network_xml.bootp(file="pxelinux.0") return str(network_xml)
def make_story_xml(self, name=None, description=None, story_type=None, owned_by=None, requested_by=None, estimate=None, current_state=None, labels=None): story = XMLBuilder('story') if name is not None: story.name(name) if description is not None: story.description(description) if requested_by is not None: story.requested_by(requested_by) if owned_by is not None: story.owned_by(owned_by) if story_type is not None: story.story_type(story_type) if estimate is not None: story.estimate(str(estimate), type='integer') if current_state is not None: story.current_state(current_state) if labels is not None: label_string = ',' if labels: label_string = ','.join(labels) story.labels(label_string) return str(story)
def make_comment_xml(self, text, author): note = XMLBuilder('note') note.text(text) if author is not None: note.author(author) return str(note)
def update_dhcpd(self): mac = re.sub('-',':',self.fuel['mac']) fuel = self.fuel ip = vlans[self.vlan]['network'] filename = "/tmp/deploy." + str(os.getpid()) x = XMLBuilder('network') x.name("lab" + str(self.vlan)) x.bridge(name = "br"+self.vlan, stp="off", delay="0") with x.forward(mode = "route", dev="eth0"): x.interface(dev="eth0") with x.ip(address = str(ip.ip+1), netmask="255.255.255.192"): with x.dhcp: x.host(mac=mac, ip=str(ip.ip+2)) x.bootp(file="pxelinux.0") x.tftp(root="/var/lib/tftpboot") print str(x)+"\n" f=open(filename,"w") f.write(str(x)+"\n") f.close() os.system("sudo ifconfig br%s down" % self.vlan) os.system("virsh net-destroy lab%s" % self.vlan) os.system("virsh net-create %s" % filename) os.system("sudo brctl addif br%s eth1.%s" % (self.vlan, self.vlan))
class TestXMLBuilder(object): def setUp(self): self.xml = XMLBuilder('root') self.xml['xml_header'] = False self.xml['formatted'] = False def test_very_simple(self): eq_(str(self.xml), "<root />") def test_xml_header(self): self.xml['xml_header'] = True eq_(str(self.xml), '<?xml version="1.0" encoding="utf-8" ?>\n<root />') def test_unicode(self): self.xml.t eq_(unicode(self.xml), u"<root><t /></root>") def test_simple1(self): self.xml.t eq_(str(self.xml), "<root><t /></root>") def test_simple2(self): self.xml.t("some_data") eq_(str(self.xml), "<root><t>some_data</t></root>") def test_simple3(self): self.xml.t(a='1') eq_(str(self.xml), '<root><t a="1" /></root>') def test_simple4(self): self.xml.t("some data", a='1') eq_(str(self.xml), '<root><t a="1">some data</t></root>') def test_simple5(self): self.xml << "some data" eq_(str(self.xml), '<root>some data</root>') def test_simple6(self): self.xml << "some data" << '111' << '222' eq_(str(self.xml), '<root>some data111222</root>') @raises(ValueError) def test_wrong_data1(self): self.xml << 3 @raises(ValueError) def test_wrong_data2(self): self.xml.t(attr=3) @raises(ValueError) def test_wrong_data2(self): self.xml.t("some_data", attr=3) @raises(ValueError) def test_wrong_data2(self): self.xml.t(True, attr=3) @raises(ValueError) def test_wrong_data3(self): self.xml.t(3) test_formatter1_res = \ """<root> <t1 m="1"> <t2 /> </t1> <t3>mmm</t3> </root>""" def test_formatter1(self): self.xml['formatted'] = True self.xml.t1(m='1').t2 self.xml.t3('mmm') eq_(str(self.xml), self.test_formatter1_res) test_formatter2_res = '<root>\n\t<t1 m="1">\n\t\t<t2 />\n\t</t1>\n\t<t3>mmm</t3>\n</root>' def test_formatter2(self): self.xml['formatted'] = True self.xml['tabstep'] = '\t' self.xml.t1(m='1').t2 self.xml.t3('mmm') eq_(str(self.xml), self.test_formatter2_res) def test_attrib(self): self.xml.t1(m='1').t2 self.xml.t3('mmm') eq_(str(self.xml), '<root><t1 m="1"><t2 /></t1><t3>mmm</t3></root>') def test_with1(self): with self.xml.tree_root: pass eq_(str(self.xml), "<root><tree_root /></root>") def test_with2(self): with self.xml.tree_root('rr'): pass eq_(str(self.xml), "<root><tree_root>rr</tree_root></root>") def test_with3(self): with self.xml.tree_root(a='dt'): pass eq_(str(self.xml), '<root><tree_root a="dt" /></root>') def test_with4(self): with self.xml.tree_root('mm', a='dt'): pass eq_(str(self.xml), '<root><tree_root a="dt">mm</tree_root></root>') def test_with5(self): with self.xml.tree_root(a='dt'): self.xml << '11' eq_(str(self.xml), '<root><tree_root a="dt">11</tree_root></root>') def test_with6(self): with self.xml.tree_root(a='dt'): self.xml << '11' self.xml.tt eq_(str(self.xml), '<root><tree_root a="dt">11<tt /></tree_root></root>') def test_unicode(self): with self.xml.tree_root(a=u'dt'): self.xml << u'11' self.xml.tt('12') eq_(str(self.xml), u'<root><tree_root a="dt">11<tt>12</tt></tree_root></root>') def test_unicode1(self): with self.xml.tree_root(a=u'dt'): self.xml << u'11' self.xml.tt('12') eq_(unicode(self.xml), u'<root><tree_root a="dt">11<tt>12</tt></tree_root></root>') def test_unicode2(self): with self.xml.tree_root(a=u'dt'): self.xml << u'бла-бла-бла' self.xml.tt('12') eq_(str(self.xml).decode('utf8'), u'<root><tree_root a="dt">бла-бла-бла<tt>12</tt></tree_root></root>') def test_with_all(self): self.xml.top with self.xml.tree_root('some data', attr='12'): self.xml.child1 self.xml.child2('child data', attr='11') with self.xml.tree_subroot(attr='13'): self.xml.very_child('very data') with self.xml.tree_subsubroot: pass eq_(str(self.xml), '<root>' + '<top />' + '<tree_root attr="12">some data' + '<child1 />' + '<child2 attr="11">child data</child2>' + '<tree_subroot attr="13">' + '<very_child>very data</very_child>' '<tree_subsubroot />' + '</tree_subroot>' + '</tree_root>' + '</root>')
def build_network_xml(self, network): network_xml = XMLBuilder('network') network_xml.name(network.id) if not network.forward is None: network_xml.forward(mode=network.forward) if hasattr(network, 'ip_addresses') and not network.ip_addresses is None: with network_xml.ip( address=str(network.ip_addresses[1]), prefix=str(network.ip_addresses.prefixlen) ): if network.pxe: network_xml.tftp(root=network.tftp_root_dir) if network.dhcp_server: with network_xml.dhcp: if hasattr(network, 'dhcp_dynamic_address_start'): start = network.dhcp_dynamic_address_start else: start = network.ip_addresses[2] if hasattr(network, 'dhcp_dynamic_address_end'): end = network.dhcp_dynamic_address_end else: end = network.ip_addresses[ network.ip_addresses.numhosts - 2] allowed_addresses = list(network.ip_addresses)[2: network.ip_addresses.numhosts - 2] network_xml.range(start=str(start), end=str(end)) for interface in network.interfaces: address = find( lambda ip: ip in allowed_addresses, interface.ip_addresses) if address and interface.mac_address: network_xml.host( mac=str(interface.mac_address), ip=str(address), name=interface.node.name) if network.pxe: network_xml.bootp(file="pxelinux.0") return str(network_xml)
def xml(self, options={}): track = True if options.get("track", True) else options.get("track") response = XMLBuilder('VAST', version=self.version) if len(self.ads) == 0 and self.VASTErrorURI: response.Error(self.cdata(self.VASTErrorURI)) return response for ad in self.ads: adOptions = {"id": ad.id} if ad.sequence: adOptions["sequence"] = str(ad.sequence) with response.Ad(**adOptions): if ad.structure.lower() == 'wrapper': with response.Wrapper: response.AdSystem( ad.AdSystem["name"], **{"version": ad.AdSystem["version"]}) response.VASTAdTagURI(self.cdata(ad.VASTAdTagURI)) if ad.Error: response.Error(self.cdata(ad.Error)) for impression in ad.impressions: if track: response.Impression( self.cdata(impression["url"])) self.add_creatives(response, ad, track) else: with response.InLine: response.AdSystem( ad.AdSystem["name"], **{"version": ad.AdSystem["version"]}) response.AdTitle(self.cdata(ad.AdTitle)) response.Description(self.cdata(ad.Description or '')) with response.Survey: for survey in ad.surveys: attributes = {} if survey.type: attributes["type"] = survey.type response.Survey(self.cdata(survey.url), **attributes) if ad.Error: response.Error(self.cdata(ad.Error)) for impression in ad.impressions: if track: response.Impression( self.cdata(impression["url"])) self.add_creatives(response, ad, track) if ad.Extensions: for extension in ad.Extensions: response.Extension(extension) return response
def _generate_xml(self, exception=None, request=None): _, _, trace = sys.exc_info() xml = XMLBuilder() tb_dict = {} tb = traceback.extract_tb(trace) if tb: tb = tb[0] tb_dict["filename"] = tb[0] tb_dict["line_number"] = tb[1] tb_dict["function_name"] = tb[2] site = Site.objects.get_current() with xml.notice(version=2.0): xml << ("api-key", self.settings["API_KEY"]) with xml.notifier: xml << ("name", site.name) xml << ("version", "0.0.1") xml << ("url", site.domain) if request: with xml.request: if request.is_secure(): scheme = "https" else: scheme = "http" url = "%s://%s%s" % (scheme, request.get_host(), request.get_full_path()) xml << ("url", url) cb, _, _ = resolve(request.path) xml << ("component", cb.__module__) xml << ("action", cb.__name__) if len(request.POST): with xml.params: for key, val in request.POST.items(): xml << ("var", str(val), {"key": key}) session = request.session.items() if len(session): with xml.session: for key, val in session.items(): xml << ("var", str(val), {"key": key}) with xml("cgi-data"): for key, val in request.META.items(): xml << ("var", str(val), {"key": key}) with xml("server-environment"): xml << ("environment-name", self.settings["ENVIRONMENT"]) if exception: with xml.error: xml << ("class", exception.__class__.__name__) xml << ("message", str(exception)) with xml.backtrace: xml << ( "line", { "file": tb_dict.get("filename", "unknown"), "number": tb_dict.get("line_number", "unknown"), "method": tb_dict.get("function_name", "unknown"), }, ) return str(xml)
def setUp(self): self.xml = XMLBuilder('root') self.xml['xml_header'] = False self.xml['formatted'] = False
def build_node_xml(self, node, emulator): """ :rtype : String :type node: Node """ node_xml = XMLBuilder("domain", type=node.hypervisor) node_xml.name( self._get_name(node.environment and node.environment.name or '', node.name)) with node_xml.cpu(mode='host-model'): node_xml.model(fallback='forbid') node_xml.vcpu(str(node.vcpu)) node_xml.memory(str(node.memory * 1024), unit='KiB') with node_xml.os: node_xml.type(node.os_type, arch=node.architecture) for boot_dev in json.loads(node.boot): node_xml.boot(dev=boot_dev) with node_xml.devices: node_xml.emulator(emulator) if node.has_vnc: if node.vnc_password: node_xml.graphics( type='vnc', listen='0.0.0.0', autoport='yes', passwd=node.vnc_password) else: node_xml.graphics( type='vnc', listen='0.0.0.0', autoport='yes') for disk_device in node.disk_devices: self._build_disk_device(node_xml, disk_device) for interface in node.interfaces: self._build_interface_device(node_xml, interface) with node_xml.video: node_xml.model(type='vga', vram='9216', heads='1') with node_xml.serial(type='pty'): node_xml.target(port='0') with node_xml.console(type='pty'): node_xml.target(type='serial', port='0') return str(node_xml)
def build_node_xml(self, node, emulator): """ :rtype : String :type node: Node """ node_xml = XMLBuilder("domain", type=node.hypervisor) node_xml.name( self._get_name(node.environment and node.environment.name or '', node.name)) node_xml.vcpu(str(node.vcpu)) node_xml.memory(str(node.memory * 1024), unit='KiB') with node_xml.os: node_xml.type(node.os_type, arch=node.architecture) for boot_dev in json.loads(node.boot): node_xml.boot(dev=boot_dev) with node_xml.devices: node_xml.emulator(emulator) if node.has_vnc: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes') for disk_device in node.disk_devices: self._build_disk_device(node_xml, disk_device) for interface in node.interfaces: self._build_interface_device(node_xml, interface) return str(node_xml)
def build_node_xml(self, node, emulator): """Generate node XML :type node: Node :type emulator: String :rtype : String """ node_xml = XMLBuilder("domain", type=node.hypervisor) node_xml.name( self._get_name(node.environment and node.environment.name or '', node.name)) with node_xml.cpu(mode='host-model'): node_xml.model(fallback='forbid') node_xml.vcpu(str(node.vcpu)) node_xml.memory(str(node.memory * 1024), unit='KiB') node_xml.clock(offset='utc') with node_xml.clock.timer(name='rtc', tickpolicy='catchup', track='wall'): node_xml.catchup(threshold='123', slew='120', limit='10000') node_xml.clock.timer(name='pit', tickpolicy='delay') node_xml.clock.timer(name='hpet', present='yes' if self.driver.hpet else 'no') with node_xml.os: node_xml.type(node.os_type, arch=node.architecture) for boot_dev in json.loads(node.boot): node_xml.boot(dev=boot_dev) if self.driver.reboot_timeout: node_xml.bios( rebootTimeout='{0}'.format(self.driver.reboot_timeout)) if node.disk_devices.filter(bus='usb'): node_xml.bootmenu(enable='yes', timeout='3000') with node_xml.devices: node_xml.controller(type='usb', model='nec-xhci') node_xml.emulator(emulator) if node.has_vnc: if node.vnc_password: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes', passwd=node.vnc_password) else: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes') for disk_device in node.disk_devices: self._build_disk_device(node_xml, disk_device) for interface in node.interfaces: self._build_interface_device(node_xml, interface) with node_xml.video: node_xml.model(type='vga', vram='9216', heads='1') with node_xml.serial(type='pty'): node_xml.target(port='0') with node_xml.console(type='pty'): node_xml.target(type='serial', port='0') return str(node_xml)
def build_node_xml(self, node, spec): node_xml = XMLBuilder("domain", type=spec.hypervisor) node_xml.name(node.id) node_xml.vcpu(str(node.cpu)) node_xml.memory(str(node.memory * 1024), unit='KiB') with node_xml.os: node_xml.type(spec.os_type, arch=node.arch) for boot_dev in node.boot: if boot_dev == 'disk': node_xml.boot(dev="hd") else: node_xml.boot(dev=boot_dev) ide_disk_names = deque( ['hd' + c for c in list('abcdefghijklmnopqrstuvwxyz')]) serial_disk_names = deque( ['sd' + c for c in list('abcdefghijklmnopqrstuvwxyz')]) def disk_name(bus='ide'): if str(bus) == 'ide': return ide_disk_names.popleft() return serial_disk_names.popleft() with node_xml.devices: node_xml.emulator(spec.emulator) if len(node.disks) > 0: node_xml.controller(type="ide") for disk in node.disks: with node_xml.disk(type="file", device="disk"): node_xml.driver( name="qemu", type=disk.format, cache="unsafe") node_xml.source(file=disk.path) node_xml.target(dev=disk_name(disk.bus), bus=disk.bus) if node.cdrom: with node_xml.disk(type="file", device="cdrom"): node_xml.driver(name="qemu", type="raw") node_xml.source(file=node.cdrom.isopath) node_xml.target( dev=disk_name(node.cdrom.bus), bus=node.cdrom.bus) for interface in node.interfaces: with node_xml.interface(type="network"): node_xml.source(network=interface.network.id) if not (interface.type is None): node_xml.model(type=interface.type) for interface in node.bridged_interfaces: with node_xml.interface(type="bridge"): node_xml.source(bridge=interface.bridge) if not (interface.type is None): node_xml.model(type=interface.type) if node.vnc: node_xml.graphics(type='vnc', listen='0.0.0.0', autoport='yes') return str(node_xml)
def convert_suite_and_result_to_xunit(suite, result, name="PysivXunitTestSuite"): """Custom a test suite and result to XML. The name is used to set the xml suitename for jenkins. <testsuite errors="1" failures="1" name="1234" skip="1" tests="5"> :param suite: unittest.TestSuite :param result: unittest.TestResult :param name: :return: XML instance """ # When a test fails in setUpClass, the result is a # unittest.suite._ErrorHolder rather than a TestCase. We need to handle # those differently. def parse_setupclass_error(klass_id): """Return what's inside the parentheses.""" return re.search("(?<=\().*(?=\))", klass_id).group(0) # Test cls names/id names = 'errors skipped failures'.split() klass_results = {} for n in names: klass_results[n] = [] for klass, out in getattr(result, n): if isinstance(klass, unittest.suite._ErrorHolder): klass_results[n].append(parse_setupclass_error(klass.id())) else: klass_results[n].append(klass.id()) nskipped = len(klass_results['skipped']) nerrors = len(klass_results['errors']) nfailures = len(klass_results['failures']) def _to_key(test_case): # If the test_case is an _ErrorHolder, the key should be parsed from # the description. It won't have a _testMethodName if isinstance(test_case, unittest.suite._ErrorHolder): return parse_setupclass_error(test_case.description) m = test_case.__module__ n = test_case.__class__.__name__ mn = test_case._testMethodName # d = test_case._testMethodDoc # return m, n, mn, d return ".".join([m, n, mn]) all_test_cases = {} for s in suite: if isinstance(s, unittest.suite.TestSuite): for tc in s: all_test_cases[_to_key(tc)] = None else: raise TypeError("Unsupported test suite case ({x})".format(x=type(s))) ntests = len(all_test_cases) # loop over failures, errors, skipped, assign message for n in names: # get all testcases with state ts = getattr(result, n) for t, msg in ts: k = _to_key(t) all_test_cases[k] = msg # import ipdb; ipdb.set_trace() # Create XML x = XMLBuilder('testsuite', name=name, tests=str(ntests), errors=str(nerrors), failures=str(nfailures), skip=str(nskipped)) for idx, message in all_test_cases.iteritems(): test_method = idx.split('.')[-1] with x.testcase(classname=idx, name=test_method, time="1.000"): if idx in klass_results['errors']: x.error(type="exceptions.Exception", message=message) elif idx in klass_results['failures']: x.failure(type="exceptions.Exception", message=message) elif idx in klass_results['skipped']: # print "skipped", idx x.skipped(type="unittest.case.SkipTest", message=message) else: # print "Success", idx pass return x
def to_xml(self): resources = self.resources x = XMLBuilder('CloudService', xmlns="http://schemas.microsoft.com/windowsazure") x['xml_header'] = True x.GeoRegion(self.geo_region) with x.Resources: for resource in self.resources: with x.Resource: x.ETag(resource.incarnation_id) x.Name(resource.name) with x.OperationStatus: x.Result("Succeeded") x.Plan(resource.plan) x.State("Started") x.SubState("Ready to go") x.Type(resource.resource_type) with x.UsageMeters: for usage_meter in resource.usage_meters: with x.UsageMeter: x.Included(usage_meter["Included"]) x.Name(usage_meter["Name"]) x.Unit(usage_meter["Unit"]) x.Used(usage_meter["Used"]) return str(x)
def to_xml(self): x = XMLBuilder('Resource', xmlns="http://schemas.microsoft.com/windowsazure") x.CloudServiceSettings() x.ETag(self.incarnation_id) x.IntrinsicSettings() x.Name(self.name) with x.OperationStatus: x.Result("Succeeded") with x.OutputItems: for key in self.output_items.keys(): with x.OutputItem: x.Key(key) x.Value(self.output_items[key]) x.Plan(self.plan) x.State(self.state) x.SubState(self.sub_state) with x.UsageMeters: for usage_meter in self.usage_meters: with x.UsageMeter: x.Included(usage_meter["Included"]) x.Name(usage_meter["Name"]) x.Unit(usage_meter["Unit"]) x.Used(usage_meter["Used"]) x.Type(self.resource_type) return str(x)
def build_network_xml(self, network): """ :type network: Network :rtype : String """ network_xml = XMLBuilder('network') network_xml.name(self._get_name( network.environment and network.environment.name or '', network.name)) if not (network.forward is None): network_xml.forward(mode=network.forward) if not (network.ip_network is None): ip_network = IPNetwork(network.ip_network) with network_xml.ip(address=str(ip_network[1]), prefix=str(ip_network.prefixlen)): if network.has_pxe_server: network_xml.tftp(root=network.tftp_root_dir) if network.has_dhcp_server: with network_xml.dhcp: network_xml.range(start=str(network.ip_pool_start), end=str(network.ip_pool_end)) for interface in network.interfaces: for address in interface.addresses: if IPAddress(address.ip_address) in ip_network: network_xml.host( mac=str(interface.mac_address), ip=str(address.ip_address), name=interface.node.name ) if network.has_pxe_server: network_xml.bootp(file="pxelinux.0") return str(network_xml)