Python resource_list.ResourceList类代码示例

 def test01_no_links(self):
     xml = run_resync(['--write-resourcelist',
                       'http://example.org/t', 'tests/testdata/dir1'])
     rl = ResourceList()
     rl.parse(fh=io.BytesIO(xml))
     self.assertEqual(len(rl), 2)
     self.assertEqual(rl.link('describedby'), None)

 def test04_dump_multi_file_max_size(self):
     rl=ResourceList()
     for letter in map(chr,xrange(ord('a'),ord('l')+1)):
         uri='http://ex.org/%s' % (letter)
         fname='resync/test/testdata/a_to_z/%s' % (letter)
         rl.add( Resource(uri, path=fname) )
     self.assertEqual( len(rl), 12 )
     d2=Dump(rl) 
     tmpbase=os.path.join(self.tmpdir,'test0f_')
     d2.max_size=2000
     n=d2.write(tmpbase)
     self.assertEqual( n, 2, 'expect to write 2 dump files' )
     self.assertTrue( os.path.isfile(tmpbase+'00000.zip') )
     self.assertTrue( os.path.isfile(tmpbase+'00001.zip') )
     # Look at the first file in detail
     zipf=tmpbase+'00000.zip'
     zo=zipfile.ZipFile(zipf,'r')
     self.assertEqual( zo.namelist(), ['manifest.xml','a','b','c','d','e','f'] )
     #self.assertEqual( zo.getinfo('manifest.xml').file_size, 470 )
     self.assertEqual( zo.getinfo('a').file_size, 9 )
     self.assertEqual( zo.getinfo('b').file_size, 1116 )
     self.assertEqual( zo.getinfo('c').file_size, 32 )
     self.assertEqual( zo.getinfo('d').file_size, 13 )
     self.assertEqual( zo.getinfo('e').file_size, 20 )
     self.assertEqual( zo.getinfo('f').file_size, 1625 )
     zo.close()
     os.unlink(zipf)
     # Check second and third files have expected contents
     zipf=tmpbase+'00001.zip'
     zo=zipfile.ZipFile(zipf,'r')
     self.assertEqual( zo.namelist(), ['manifest.xml','g','h','i','j','k','l'] )
     zo.close()
     os.unlink(zipf)

    def read_reference_resource_list(self,ref_sitemap,name='reference'):
        """Read reference resource list and return the ResourceList object

        name parameter just uses in output messages to say what type
        of resource list is being read.
        """
        rl = ResourceList()
        self.logger.info("Reading reference %s resource list from %s ..." % (name,ref_sitemap))
        rl.mapper=self.mapper
        rl.read(uri=ref_sitemap,index_only=(not self.allow_multifile))
        num_entries = len(rl.resources)
        self.logger.info("Read %s resource list with %d entries in %d sitemaps" % (name,num_entries,rl.num_files))
        if (self.verbose):
            to_show = 100
            override_str = ' (override with --max-sitemap-entries)'
            if (self.max_sitemap_entries):
                to_show = self.max_sitemap_entries
                override_str = ''
            if (num_entries>to_show):
                print "Showing first %d entries sorted by URI%s..." % (to_show,override_str)
            n=0
            for r in rl.resources:
                print r
                n+=1
                if ( n >= to_show ):
                    break
        return(rl)

 def test00_dump_creation(self):
     i = ResourceList()
     i.add(Resource("http://ex.org/a", length=1, path="resync/test/testdata/a"))
     i.add(Resource("http://ex.org/b", length=2, path="resync/test/testdata/b"))
     d = Dump()
     d.check_files(resource_list=i)
     self.assertEqual(d.total_size, 28)

 def test20_as_xml(self):
     rl = ResourceList()
     rl.add( Resource('a',timestamp=1) )
     rl.add( Resource('b',timestamp=2) )
     xml = rl.as_xml()
     self.assertTrue( re.search(r'<rs:md .*capability="resourcelist"', xml), 'XML has capability' )
     self.assertTrue( re.search(r'<url><loc>a</loc><lastmod>1970-01-01T00:00:01Z</lastmod></url>', xml), 'XML has resource a' ) 

 def test_build_ex_01(self):
     """Simple Resource List document """
     rl = ResourceList()
     rl.md_at = '2013-01-03T09:00:00Z'
     rl.add( Resource('http://example.com/res1') )
     rl.add( Resource('http://example.com/res2') )
     ex_xml = self._open_ex('resourcesync_ex_1').read()
     self._assert_xml_equal( rl.as_xml(), ex_xml )

 def test_09_print_from_iter(self): 
     r1 = Resource(uri='a',lastmod='2001-01-01',length=1234)
     r2 = Resource(uri='b',lastmod='2002-02-02',length=56789)
     m = ResourceList()
     m.add(r1)
     m.add(r2)
     i = iter(m)
     self.assertEqual( Sitemap().resources_as_xml(i), "<?xml version='1.0' encoding='UTF-8'?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:rs=\"http://www.openarchives.org/rs/terms/\"><url><loc>a</loc><lastmod>2001-01-01T00:00:00Z</lastmod><rs:md length=\"1234\" /></url><url><loc>b</loc><lastmod>2002-02-02T00:00:00Z</lastmod><rs:md length=\"56789\" /></url></urlset>")

 def test_ex_01(self):
     """resourcesync_ex_1 is a simple resource_list with 2 resources, no metadata"""
     rl=ResourceList()
     rl.parse(uri='tests/testdata/examples_from_spec/resourcesync_ex_1.xml')
     self.assertEqual( rl.capability, 'resourcelist' )
     self.assertEqual( len(rl.resources), 2, '2 resources')
     sms = sorted(rl.uris())
     self.assertEqual( sms, ['http://example.com/res1','http://example.com/res2'] )
     self.assertEqual( rl.resources['http://example.com/res1'].lastmod, None )

 def test_08_print_non_ascii_uri(self):
     """Verify that valid Unicode uri values give good XML out."""
     m = ResourceList(md={'capability': 'resourcelist', 'modified': None})
     m.add(Resource(uri=u'a_\u00c3_b'))
     m.add(Resource(uri=u'c_\u1234_d'))
     xml = Sitemap().resources_as_xml(m)
     self.assertTrue(re.search(u'<loc>a_.*_b</loc>', xml))
     self.assertTrue(re.search(u'<loc>a_\u00c3_b</loc>', xml))
     self.assertTrue(re.search(u'<loc>c_\u1234_d</loc>', xml))

 def test20_as_xml(self):
     rl = ResourceList()
     rl.add( Resource('a',timestamp=1) )
     rl.add( Resource('b',timestamp=2) )
     xml = rl.as_xml()
     print xml
     self.assertTrue( re.search(r'<rs:md .*capability="resourcelist"', xml), 'XML has capability' )
     self.assertTrue( re.search(r'<rs:md .*modified="\d\d\d\d\-\d\d\-\d\dT\d\d:\d\d:\d\dZ"', xml), 'XML has modified to seconds precision (and not more)' )
     self.assertTrue( re.search(r'<url><loc>a</loc><lastmod>1970-01-01T00:00:01Z</lastmod></url>', xml), 'XML has resource a' ) 

 def test_ex_08(self):
     """resourcesync_ex_8 is a simple Resource List Index with 2 Resource Lists"""
     rl=ResourceList()
     rl.read(uri='tests/testdata/examples_from_spec/resourcesync_ex_8.xml',index_only=True)
     self.assertEqual( rl.capability, 'resourcelist' )
     self.assertEqual( rl.md_at, '2013-01-03T09:00:00Z' )
     self.assertEqual( len(rl.resources), 2, '2 resources')
     sms = sorted(rl.uris())
     self.assertEqual( sms, ['http://example.com/resourcelist-part1.xml',
                             'http://example.com/resourcelist-part2.xml'] )

 def test_08_print(self):
     r1 = Resource(uri='a',lastmod='2001-01-01',length=1234)
     r2 = Resource(uri='b',lastmod='2002-02-02',length=56789)
     r3 = Resource(uri='c',lastmod='2003-03-03',length=0)
     m = ResourceList(md={'capability':'resourcelist','modified':None})
     m.add(r1)
     m.add(r2)
     m.add(r3)
     #print m
     self.assertEqual( Sitemap().resources_as_xml(m), "<?xml version='1.0' encoding='UTF-8'?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:rs=\"http://www.openarchives.org/rs/terms/\"><rs:md capability=\"resourcelist\" /><url><loc>a</loc><lastmod>2001-01-01T00:00:00Z</lastmod><rs:md length=\"1234\" /></url><url><loc>b</loc><lastmod>2002-02-02T00:00:00Z</lastmod><rs:md length=\"56789\" /></url><url><loc>c</loc><lastmod>2003-03-03T00:00:00Z</lastmod><rs:md length=\"0\" /></url></urlset>")

 def test_01_read_local_filenames(self):
     rl = ResourceList()
     rl.read('tests/testdata/sitemapindex2/sitemap.xml')
     self.assertEqual( len(rl.resources), 17, '17 resources from 3 sitemaps listed')
     sr = sorted(rl.uris())
     self.assertEqual( sr[0], 'http://localhost:8888/resources/1' )
     self.assertEqual( sr[1], 'http://localhost:8888/resources/10' )
     self.assertEqual( sr[2], 'http://localhost:8888/resources/100' )
     self.assertEqual( sr[3], 'http://localhost:8888/resources/1000' )
     self.assertEqual( sr[16], 'http://localhost:8888/resources/826' )

    def test31_parse_no_capability(self):
        xml='<?xml version=\'1.0\' encoding=\'UTF-8\'?>\n\
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\
<url><loc>http://example.com/res1</loc><lastmod>2012-03-14T18:37:36Z</lastmod></url>\
</urlset>'
        rl=ResourceList()
        rl.parse(fh=io.StringIO(xml))
        self.assertEqual( len(rl.resources), 1, 'got 1 resource')
        self.assertEqual( rl.md['capability'], 'resourcelist', 'capability set by reading routine' )
        self.assertFalse( 'from' in rl.md )

 def test06_add_changed_resources(self):
     added = ResourceList()
     added.add( Resource('a',timestamp=1,change='created') )
     added.add( Resource('d',timestamp=4,change='created') )
     self.assertEqual(len(added), 2, "2 things in added resource_list")
     changes = ChangeList()
     changes.add_changed_resources( added, change='created' )
     self.assertEqual(len(changes), 2, "2 things added")
     i = iter(changes)
     first = next(i)
     self.assertEqual(first.uri, 'a', "changes[0].uri=a")
     self.assertEqual(first.timestamp, 1, "changes[0].timestamp=1")
     self.assertEqual(first.change, 'created') #, "changes[0].change=createdd")
     second = next(i)
     self.assertEqual(second.timestamp, 4, "changes[1].timestamp=4")
     self.assertEqual(second.change, 'created', "changes[1].change=createdd")
     # Now add some with updated (one same, one diff)
     updated = ResourceList()
     updated.add( Resource('a',timestamp=5,change='created') )
     updated.add( Resource('b',timestamp=6,change='created') )
     self.assertEqual(len(updated), 2, "2 things in updated resource_list")
     changes.add_changed_resources( updated, change='updated' )
     self.assertEqual(len(changes), 4, "4 = 2 old + 2 things updated")
     # Make new resource_list from the changes which should not have dupes
     dst = ResourceList()
     dst.add( changes, replace=True )
     self.assertEqual(len(dst), 3, "3 unique resources")
     self.assertEqual(dst.resources['a'].timestamp, 5 ) # 5 was later in last the 1
     self.assertEqual(dst.resources['a'].change, 'updated')
     self.assertEqual(dst.resources['b'].timestamp, 6)
     self.assertEqual(dst.resources['b'].change, 'updated')
     self.assertEqual(dst.resources['d'].timestamp, 4)
     self.assertEqual(dst.resources['d'].change, 'created')