Python xobj.parse函数代码示例

    def testPOST(self):
        # Test POST of an XObj object tree.
        xml = self.getArchiveContents('employee1.xml')
        doc = xobj.parse(xml)
        model = doc.employee

        robj = self._client.do_POST('/employees', model)
        employee = robj._root

        # Make sure the model that is returned matches the one that was sent.
        self.failUnlessEqual(model.name, employee.name)
        self.failUnlessEqual(model.address.street, employee.address.street)
        self.failUnlessEqual(model.address.city, employee.address.city)
        self.failUnlessEqual(model.address.state, employee.address.state)
        self.failUnlessEqual(model.address.zipcode, employee.address.zipcode)
        self.failUnlessEqual(model.phone, employee.phone)
        self.failUnlessEqual(employee.employeeid, '0')
        self.failUnlessEqual(employee.id, '/api/employees/0')

        # Make sure there is an error raised when no document is provided.
        self.failUnlessRaises(TypeError, self._client.do_POST, '/employees')

        # Make sure POST of an XObj document works.
        xml2 = self.getArchiveContents('employee2.xml')
        doc2 = xobj.parse(xml2)

        robj = self._client.do_POST('/employees', doc2)
        employee2 = robj._root

        self.failUnlessEqual(doc2.employee.name, employee2.name)
        self.failUnlessEqual(employee2.employeeid, '1')

 def testImageOrdering(self):
     user = usermodels.User.objects.get(user_name='ExampleDeveloper')
     stage = projectsmodels.Stage.objects.filter(
         project__short_name='chater-foo',
         project_branch__name='1',
         name='Development')[0]
     for name in [ 'a', 'b', 'c', 'A', 'B', 'C' ]:
         img = models.Image(name=name,
                 project_branch_stage=stage,
                 created_by=user,
                 status=300)
         self.mgr.createImageBuild(img, for_user=user)
     self.mgr.commit()
     response = self._get('query_sets/%s/all;order_by=name' % self.all_images.query_set_id,
             username='ExampleDeveloper', password='password')
     self.assertEquals(response.status_code, 200)
     doc = xobj.parse(response.content)
     self.assertEquals(
             [ x.name for x in doc.images.image ],
             ['A', 'B', 'C', 'a', 'b', 'c'])
     # Same deal, reverse order
     response = self._get('query_sets/%s/all;order_by=-name' % self.all_images.query_set_id,
             username='ExampleDeveloper', password='password')
     self.assertEquals(response.status_code, 200)
     doc = xobj.parse(response.content)
     self.assertEquals(
             [ x.name for x in doc.images.image ],
             ['c', 'b', 'a', 'C', 'B', 'A'])

    def testQuerySetWithMissingFilter(self):
        # RCE-1879
        # Create queryset
        response = self._post('query_sets/',
            data=testsxml.queryset_post_xml,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        xobjModel = xobj.parse(response.content)

        qs1 = models.QuerySet.objects.get(
                query_set_id=str(xobjModel.query_set.query_set_id))
        xml = """\
<query_set>
  <filter_entries>
    <filter_entry>
      <operator>LIKE</operator>
      <field>name</field>
      <value>jdl</value>
    </filter_entry>
    <filter_entry>
      <field/>
      <operator>EQUAL</operator>
      <value/>
    </filter_entry>
  </filter_entries>
</query_set>
"""
        response = self._put("query_sets/%s" % qs1.pk,
            username="admin", password="password",
            data=xml)
        self.assertEquals(response.status_code, 400)
        xobjModel = xobj.parse(response.content)
        self.assertEquals(xobjModel.fault.message,
                'null value in column "field" violates not-null constraint\nDETAIL:  Failing row contains (21, null, EQUAL, null).\n')

def do_project_branches_list(self, options):

    h2 = httplib2.Http("~/.rpathcmd/.cache")
    h2.disable_ssl_certificate_validation = True
    h2.add_credentials(self.options.username, self.options.password)

    branchesdatapages = []
  
    tmpxml =  h2.request('http://' + self.options.server + '/api/v1/project_branches')
    branchesdatapages.append(tmpxml[1])

    tmpdata = xobj.parse(tmpxml[1])

    #epdb.st()
    if int(tmpdata.project_branches.num_pages) == 1:
        print "#one page"
    else:
        print "pagination not yet supported"
        sys.exit(1)

    for branchesdatapage in branchesdatapages:
        branchesdata = xobj.parse(branchesdatapage)
        for project_branch in branchesdata.project_branches.project_branch:
            #epdb.st()
            print "%s: %s %s" % (project_branch.branch_id, 
                                project_branch.project.short_name, 
                                project_branch.name)

    def testGetQuerySetAll(self):
        # show that we can get results from a query set
        qsid = self._getQs("All Systems")
        response = self._get("query_sets/%s/all;start_index=0;limit=9999" % qsid,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        systems = xobj.parse(response.content)
        count = len(systems.systems.system)
        self.failUnlessEqual(count, 201)

        # we will have tagged it by visiting the last pass
        # now hit it again and run down the "tagged" path
        # for code coverage purposes & make sure we get
        # the same result
        response = self._get("query_sets/%s/all;start_index=0;limit=9999" % qsid,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        systems = xobj.parse(response.content)
        count = len(systems.systems.system)
        self.failUnlessEqual(count, 201)

        # since we just fetched the queryset, the queryset entry itself
        # should now have an invalidation job on it which we can use
        # have it re-tag on the next pass
        response = self._get("query_sets/%s" % qsid,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        self.assertXMLEquals(response.content, testsxml.queryset_with_actions,
          ignoreNodes=[
             'filter_entry_id', 'created_date',
             'last_login_date', 'created_by', 'modified_by',
             'tagged_date', 'modified_date', 'is_public', 'is_static',
          ])

        # every queryset should have a "universe" URL that points to the all
        # collection for the given queryset type
        response = self._get("query_sets/%s/universe" % qsid,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)

        # the tagged date should be set because we ran the queryset 
        # at least once.
        # post the invalidation job to the queryset and verify the tagged
        # date goes back to null
        queryset = models.QuerySet.objects.get(pk=qsid)
        self.assertTrue(queryset.tagged_date is not None)
        response = self._post("query_sets/%s/jobs" % qsid,
            data=testsxml.queryset_invalidate_post_xml, 
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        queryset = models.QuerySet.objects.get(pk=qsid)
        self.assertEquals(queryset.tagged_date, None)

        # verify that asking for 0 results returns 0 results
        # (not this should happen)
        response = self._get("query_sets/%s/all;start_index=0;limit=0" % qsid,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)

 def _testUpdateImageBuildFile(self, username, expected_code):
     response = self._post('images/1/build_files/',
         username=username, password='password', data=testsxml.build_file_post_xml)
     self.assertEqual(response.status_code, expected_code)
     if expected_code != 200:
         return
     buildFile = xobj.parse(response.content)
     file_id = buildFile.file.file_id
     response = self._put('images/1/build_files/%s' % file_id,
         username=username, password='password', data=testsxml.build_file_put_xml)
     self.assertEquals(response.status_code, expected_code)
     buildFileUpdated = xobj.parse(response.content)
     self.assertEquals(buildFileUpdated.file.title, 'newtitle')

    def testAddProject(self):

        response = self._post('projects',
            data=testsxml.project_post_xml,
            username="admin", password="password")
        self.assertEquals(response.status_code, 200)
        project = xobj.parse(response.content).project
        projectId = project.project_id
        project = models.Project.objects.get(pk=projectId)
        self.assertEquals("test-project", project.name)
        self.assertEquals(1, project.created_by.user_id)
        self.assertEquals(1, project.modified_by.user_id)
        self.assertTrue(project.created_date is not None)
        self.assertTrue(project.modified_date is not None)

        # adding project again should give a 400 error
        response = self._post('projects',
            data=testsxml.project_post_xml,
            username="admin", password="password")
        self.assertEquals(response.status_code, 409)

        # same short name, different name (APPENG-2999)
        xml = testsxml.project_post_xml.replace("<name>test-project</name>",
                "<name>another test project</name>")
        response = self._post('projects',
            data=xml,
            username="admin", password="password")
        self.assertEquals(response.status_code, 409)

    def configureTargetCredentials(self, target, ddata):
        '''
        Configure credentials for a target

        @param ddata: descriptor for target
        @type ddata: DescriptorData
        @param target: target to configure
        @type target: rObj(target)
        @return: the configured target
        @rtype: rObj(target)
        '''
        # make sure our target object is up to date
        target.refresh()

        doc = xobj.Document()
        doc.job = job = xobj.XObj()
        job.job_type = target.actions[1]._root.job_type
        job.descriptor = target.actions[1]._root.descriptor
        job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data

        jobObj = target.jobs.append(doc)
        while jobObj.job_state.name in ['Queued', 'Running']:
            jobObj.refresh()

        if jobObj.job_state.name == 'Failed':
            raise errors.RbuildError('Unable to set credentials')
        return target

    def testCanGetImageTypeDefinitionDescriptor(self):

        # make sure we can load all the valid types
        for image_type in mint.buildtypes.xmlTagNameImageTypeMap.keys():
            # we do not have XML for netboot/live because they're deprecated
            # and deferred is special so we want to test differently
            if image_type in ['netbootImage', 'liveIsoImage', 'deferredImage']:
                continue
            # verify we can get the descriptor
            url = "platforms/image_type_definition_descriptors/%s" % image_type
            response = self._get(url) #, username='admin', password='password')
            self.assertEquals(response.status_code, 200)
            model = xobj.parse(response.content)
            self.failUnlessEqual(model.descriptor._xobj.tag, 'descriptor')
            # Check for constraints
            fields = dict((x.name, x) for x in model.descriptor.dataFields.field)
            field = fields.get('options.freespace')
            if field is not None:
                self.assertEquals(field.constraints.range.min, '16')
            field = fields.get('options.swapSize')
            if field is not None:
                self.assertEquals(field.constraints.range.min, '16')
            field = fields.get('options.vmMemory')
            if field is not None:
                self.assertEquals(field.constraints.range.min, '256')
            field = fields.get('options.vmCPUs')
            if field is not None:
                self.assertEquals(field.constraints.range.min, '1')
                self.assertEquals(field.constraints.range.max, '32')

        # an invalid one should 404
        response = self._get('platforms/image_type_definition_descriptors/doesNotExist')
        #    username='admin', password='password')
        self.assertEquals(response.status_code, 404)

    def testCreateJob(self):
        jobXml = """
<job>
  <job_type id="http://localhost/api/v1/inventory/event_types/19"/>
  <descriptor id="http://testserver/api/v1/target_types/6/descriptor_create_target"/>
  <descriptor_data>
    <alias>newbie</alias>
    <description>Brand new cloud</description>
    <name>newbie.eng.rpath.com</name>
    <zone>Local rBuilder</zone>
  </descriptor_data>
</job>
"""
        response = self._post('jobs', jobXml,
            username='testuser', password='password')
        self.assertEquals(response.status_code, 200)
        obj = xobj.parse(response.content)
        job = obj.job
        self.failUnlessEqual(job.descriptor.id, "http://testserver/api/v1/target_types/6/descriptor_create_target")

        dbjob = models.Job.objects.get(job_uuid=unicode(job.job_uuid))
        # Make sure the job is related to the target type
        self.failUnlessEqual(
            [ x.target_type.name for x in dbjob.jobtargettype_set.all() ],
            [ 'xen-enterprise' ],
        )

    def testCanListPermissions(self):
        url = 'rbac/grants'
        content = self.req(url, method='GET', expect=403, is_authenticated=True)
        content = self.req(url, method='GET', expect=200, is_admin=True)

        obj = xobj.parse(content)
        found_items = self._xobj_list_hack(obj.grants.grant)
        self.assertEqual(len(found_items), 10, 'right number of items')
        # no need to test full list dump, have test of single
        # self.assertXMLEquals(content, testsxml.permission_list_xml)

        # verify that grants also show up on roles objects
        # via associations
        url = 'rbac/roles'
        content = self.req(url, method='GET', expect=200, is_admin=True)
        self.assertXMLEquals(content, testsxml.role_list_xml_with_grants)

        # verify that we can also retrieve permissions (grants) via
        # queryset and the result is the same as from the collection
        queryset = querymodels.QuerySet.objects.get(name='All Grants')
        url = "query_sets/%s/all" % queryset.pk
        content = self.req(url, method='GET', expect=200, is_admin=True)
        # listing test no longer needed
        # self.assertXMLEquals(content, testsxml.permission_queryset_xml)

        # verify we can list permissions off the role itself
        sysadmin = models.RbacRole.objects.get(name='sysadmin')
        url = "rbac/roles/%s/grants/" % sysadmin.pk
        content = self.req(url, method='GET', expect=200, is_admin=True)
        self.assertXMLEquals(content, testsxml.permission_list_xml_for_role)

    def testUpdateJob(self):
        jobUuid = 'jobUuid1'
        jobToken = 'jobToken1'
        job = self._newJob(jobUuid, jobToken=jobToken,
            jobType=models.EventType.TARGET_REFRESH_IMAGES)

        jobXml = """
<job>
  <job_status>Completed</job_status>
  <status_code>200</status_code>
  <status_text>Some status here</status_text>
  <results encoding="identity">
    <images>
      <image id="id1">
        <imageId>id1</imageId>
      </image>
      <image id="id2">
        <imageId>id2</imageId>
      </image>
    </images>
  </results>
</job>
"""
        response = self._put('jobs/%s' % jobUuid, jobXml,
            jobToken=jobToken)
        self.assertEquals(response.status_code, 200)
        obj = xobj.parse(response.content)
        self.failUnlessEqual(obj.job.id, "http://testserver/api/v1/jobs/%s" % job.job_uuid)

    def testLocalCacheOfCollections(self):
        xml = """\
<?xml version='1.0' encoding='UTF-8'?>
<results>
  <package>
    <components>
      <component>
        <uuid>DA94B959-D786-4D58-8428-2991DE6A4FE5</uuid>
        <path>Program Files\WindowsAppTest</path>
      </component>
      <component>
        <uuid>DA94B959-D786-4D58-8428-2991DE6A4FE6</uuid>
        <path>Program Files\WindowsAppTest2</path>
      </component>
    </components>
  </package>
</results>
"""

        doc = xobj.parse(xml)
        root = doc.results

        results = rObjProxy('/results', None, root, parent=None)

        self.failUnlessEqual(results.package.components[0].uuid,
            'DA94B959-D786-4D58-8428-2991DE6A4FE5')
        self.failUnlessEqual(results.package.components[1].uuid,
            'DA94B959-D786-4D58-8428-2991DE6A4FE6')

    def _createJob(self, action_type, image_name, target_name, doLaunch):
        rb = self.handle.facade.rbuilder

        images = self.getImages(image_name)
        target = rb.getTargets(name=target_name)
        if not target:
            raise errors.PluginError("No target matching '%s'" % target_name)
        target = target[0]
        if target.is_configured == 'false':
            raise errors.PluginError(("Target '{0}' is not configured. Try"
                " running \"rbuild edit target '{0}'\" or contacting"
                " your rbuilder administrator.").format(target.name))

        if target.credentials_valid == 'false':
            raise errors.PluginError(("Target '{0}' does not have valid"
                " credentials. Try running \"rbuild edit target '{0}'\""
                " and updating your credentials.").format(target.name))

        image, action = self._getAction(images, target, action_type)

        ddata = self.handle.DescriptorConfig.createDescriptorData(
            fromStream=action.descriptor)

        doc = xobj.Document()
        doc.job = job = xobj.XObj()

        job.job_type = action._root.job_type
        job.descriptor = action._root.descriptor
        job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data

        if doLaunch:
            return image.jobs.append(doc)

    def cancel(self, image):
        '''
        Cancel a currently running image build

        :param image: image obj
        :type image: rObj(image)
        '''
        if image.status != '100':
            raise CancelImageError(msg="Image '%s' is not currently building" %
                image.image_id)

        cancelAction = [a for a in image.actions if a.key == self.CANCEL]
        if not cancelAction:
            raise CancelImageError(msg="Unable to find cancel action for"
                " image '%s'" % image.image_id)
        cancelAction = cancelAction[0]
        ddata = self.handle.DescriptorConfig.createDescriptorData(
            fromStream=cancelAction.descriptor)
        doc = xobj.Document()
        doc.job = job = xobj.XObj()

        job.job_type = cancelAction._root.job_type
        job.descriptor = cancelAction._root.descriptor
        job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
        return image.jobs.append(doc)