source: collective.imstransport/trunk/collective/imstransport/tests/testCC.py @ 207

Revision 207, 24.9 KB checked in by jon, 4 years ago (diff)

Adding new tests and changes to read package metadata
Line 
1
2from base import IMSTransportTestCase
3from collective.imstransport.utilities.imscc.ccreader import CCReader
4from collective.imstransport.utilities.imscc.ccwriter import CCWriter
5from unittest import TestSuite, makeSuite
6from xml.dom import minidom
7
8toplevel = """
9    <general>
10      <identifier>
11        <catalog>http://somewhere.com</catalog>
12        <entry>asdf</entry>
13      </identifier>
14      <title>
15        <string xml:lang="en">test module</string>
16      </title>
17      <language>en</language>
18      <description>
19        <string xml:lang="en">This is a test module</string>
20      </description>
21      <keyword>
22        <string xml:lang="en">test</string>
23        <string xml:lang="en">module</string>
24        <string xml:lang="en">educational</string>
25      </keyword>
26    </general>
27"""
28
29organizations = """<organizations>
30  <organization identifier="1000" structure="rooted-hierarchy">
31    <item identifier="1001">
32      <item identifier="1002" identifierref="2000" />
33      <item identifier="1003" identifierref="2001">
34        <title>Test Title</title>
35      </item>
36    </item>
37  </organization>
38</organizations>
39"""
40
41resources = """<resources>
42  <resource identifier="2000" href="test.html" type="webcontent" />
43</resources>
44"""
45
46general = """<general>
47  <identifier>
48    <catalog>http://somewhere.com</catalog>
49    <entry>asdf</entry>
50  </identifier>
51  <title>
52    <string xml:lang="en">asdf</string>
53  </title>
54  <language>en</language>
55  <description>
56    <string xml:lang="en">this is a test</string>
57  </description>
58  <keyword>
59    <string xml:lang="en">Hello</string>
60    <string xml:lang="en">There</string>
61  </keyword>
62</general>
63"""
64
65lifecycle = """<lifeCycle>
66  <contribute>
67    <role>
68      <source>
69        <string xml:lang="en">LOMv1.0</string>       
70      </source>
71      <value>
72        <string xml:lang="en">author</string>
73      </value>
74    </role>
75    <entity>
76BEGIN:VCARD
77FN: Sandra Suzannah Serendipity
78END:VCARD
79    </entity>
80    <entity>
81BEGIN:VCARD
82FN:HUGO
83END:VCARD
84    </entity>
85    <entity>
86BEGIN:VCARD
87FN: Quincy Adams
88END:VCARD
89    </entity>
90    <date>
91      <dateTime>
922009-05-09 15:07:16
93      </dateTime>
94    </date>
95  </contribute>
96  <contribute>
97    <role>
98      <source>
99        <string xml:lang="en">LOMv1.0</string>       
100      </source>
101      <value>
102        <string xml:lang="en">unknown</string>
103      </value>
104    </role>
105    <entity>
106BEGIN:VCARD
107FN:Garth
108END:VCARD
109    </entity>
110    <date>
111      <dateTime>
1122009-05-11 15:07:16
113      </dateTime>
114    </date>
115  </contribute>
116</lifeCycle>
117"""
118
119technical = """<technical>
120  <format>
121    image/png
122  </format>
123</technical>
124"""
125
126rights = """<rights>
127  <copyrightAndOtherRestrictions>
128    <source>
129      LOMv1.0
130    </source>
131      <value>
132        yes
133      </value>
134   </copyrightAndOtherRestrictions>
135   <description>
136     <string xml:lang="x-none">This material is copyrighted.</string>
137   </description>
138</rights>
139"""
140
141entity="""<entity>
142  BEGIN:VCARD
143  FN:  Harrison Cheever
144  EMAIL;INTERNET: harrc@plone.org
145  END:VCARD
146</entity>
147"""
148
149
150linkinfo = """<?xml version="1.0" encoding="utf-8"?>
151<wl:webLink xmlns:wl="http://www.imsglobal.org/xsd/imswl_v1p0" xmlns:xsi="xsi:http://www.w3.org/2001/XMLSchema-instance">
152        <title>Plone Website</title>
153        <url href="http://www.plone.org" target="_blank"/>
154</wl:webLink>"""
155
156LOM_IMSCC_namespace = 'http://ltsc.ieee.org/xsd/imscc/LOM'
157LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM'
158metadata = general + lifecycle
159
160class TestCCReader(IMSTransportTestCase):
161    """
162    """
163
164    def testParseManifest(self):
165        """ Test parsing of manifest node """
166        ccr = CCReader()
167        doc = ccr.parseManifest('<test>Hello</test>')
168        assert(doc.getElementsByTagName('test'))
169
170    def testReadPackageMetadata(self):
171        """ Test the reading of package level metadata """
172        ccr = CCReader()
173        manifest = '<metadata><lom xmlns="%s">' %LOM_IMSCC_namespace + toplevel + '</lom></metadata>'
174        doc = ccr.parseManifest(manifest)
175        pmd = {}
176        ccr.readPackageMetadata(doc, pmd)
177        assert(pmd.has_key('title'))
178        self.assertEqual(pmd['title'], 'test module')
179        assert(pmd.has_key('language'))
180        self.assertEqual(pmd['language'], 'en')
181        assert(pmd.has_key('description'))
182        self.assertEqual(pmd['description'], 'This is a test module')
183        assert(pmd.has_key('subject'))
184        self.assertEqual(pmd['subject'], ['test', 'module', 'educational'])
185
186    def testReadOrganizations(self):
187        """ Test organization node handling """
188        ccr = CCReader()
189        doc = minidom.parseString(organizations)
190        orgs = ccr.readOrganizations(doc)
191        assert(orgs)
192        self.assertEqual(len(orgs), 3)
193        self.assertEqual(orgs['2000'], (2, None))
194        self.assertEqual(orgs['2001'], (3, 'Test Title'))
195
196    def testReadResources(self):
197        """ Test resource node handling """
198        ccr = CCReader()
199        doc = minidom.parseString(resources)
200        res = ccr.readResources(doc)
201        assert(res)
202        self.assertEqual('2000', res[0].getAttribute('identifier'))
203        self.assertEqual('test.html', res[0].getAttribute('href'))
204        self.assertEqual('webcontent', res[0].getAttribute('type'))
205
206    def testGetTextValue(self):
207        """ Test removal of text from node """
208        document = minidom.parseString('<test>Hello</test>')
209        textnode = document.getElementsByTagName('test')[0]
210        ccr = CCReader()
211        self.assertEqual(ccr.getTextValue(textnode), 'Hello')
212
213    def testReadResourceAttributes(self):
214        """ Test resource attributes handling """
215        ccr = CCReader()
216        doc = ccr.parseManifest(resources)
217        res = doc.getElementsByTagName('resource')
218        results = ccr.readResourceAttributes(res[0])
219        self.assertEqual(results[0], '2000')
220        self.assertEqual(results[1], 'webcontent')
221        self.assertEqual(results[2], 'test.html')
222
223    def testReadMetadata(self):
224        pass
225
226    def testReadGeneral(self):
227        """ Test general node handling """
228        ccr = CCReader()
229        manifest = '<lom xmlns="%s">' %LOM_namespace + general + '</lom>'
230        doc = ccr.parseManifest(manifest)
231        md = {}
232        ccr.readGeneral(doc, md)
233        assert(md.has_key('title'))
234        self.assertEqual(md['title'], 'asdf')
235        assert(md.has_key('language'))
236        self.assertEqual(md['language'], 'en')
237        assert(md.has_key('description'))
238        self.assertEqual(md['description'], 'this is a test')
239        assert(md.has_key('subject'))
240        self.assertEqual(md['subject'], ['Hello', 'There'])
241
242    def testReadLifecycle(self):
243        """ Test lifecycle node handling """
244        ccr = CCReader()
245        manifest = '<lom xmlns="%s">' %LOM_namespace + lifecycle + '</lom>'
246        doc = ccr.parseManifest(manifest)
247        md = {}
248        ccr.readLifecycle(doc, md)
249        assert(md.has_key('creators'))
250        self.assertEqual(md['creators'], ['Sandra Suzannah Serendipity','HUGO','Quincy Adams'])
251        assert(md.has_key('contributors'))
252        self.assertEqual(md['contributors'], ['Garth'])
253        assert(md.has_key('creation_date'))
254        self.assertEqual(md['creation_date'], '2009-05-09 15:07:16')
255
256    def testTechnical(self):
257        """ Test technical node handling """
258        ccr = CCReader()
259        manifest = '<lom xmlns="%s">' %LOM_namespace + technical + '</lom>'
260        doc = ccr.parseManifest(manifest)
261        md = {}
262        ccr.readTechnical(doc, md)
263        assert(md.has_key('Format'))
264        self.assertEqual(md['Format'], 'image/png')
265
266
267    def testReadRights(self):
268        """ Test rights node handling """
269        ccr = CCReader()
270        manifest = '<lom xmlns="%s">' %LOM_namespace + rights + '</lom>'
271        doc = ccr.parseManifest(manifest)
272        md = {}
273        ccr.readRights(doc, md)
274        assert(md.has_key('rights'))
275        self.assertEqual(md['rights'],'This material is copyrighted.')
276
277    def testReadLinkInfo(self):
278        """ Test reading link """
279        ccr = CCReader()
280        title, link = ccr.getLinkInfo(linkinfo)
281        self.assertEqual(title, 'Plone Website')
282        self.assertEqual(link, 'http://www.plone.org')
283
284    def testVcardValues(self):
285        """ Testing reading VCards Sections """
286        ccr = CCReader()
287        manifest = '<lom xmlns="%s">' %LOM_namespace + entity + '</lom>'
288        doc = ccr.parseManifest(manifest)
289        md = {}
290        entity_nodes = doc.getElementsByTagName('entity')
291        name, email = ccr.getVcardValues(entity_nodes[0])
292        self.assertEqual(name, 'Harrison Cheever')
293        self.assertEqual(email, 'harrc@plone.org')
294
295    def testVcardValue(self):
296        """ Test reading of VCard line """
297        ccr = CCReader()
298        text = '\n  FN:    Howard Maggleby \n '
299        val = ccr.getVcardValue('FN', text.split('\n'))
300        self.assertEqual(val, 'Howard Maggleby')
301
302class TestCCWriter(IMSTransportTestCase):
303    """
304    """
305   
306    def testWriteManifest(self):
307        """ Test for writing of manifest """
308        ccw = CCWriter()
309        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
310        man = doc.getElementsByTagName('manifest')
311        id = man[0].getAttribute('identifier')
312        ver = man[0].getAttribute('xmlns:version')
313        self.assertEqual(id, '001')
314        self.assertEqual(ver, '2009-05-12 15:07:34')
315
316    def testTopLevelMeta(self):
317        """ Test for writing of top level metadata """
318        ccw = CCWriter()
319        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
320        LOM_IMSCC_namespace = 'http://ltsc.ieee.org/xsd/imscc/LOM'
321        ccw.writeTopLevelMetadata(doc, '001', 'Test Module', 'http://plone.org', 'en', 'This is a test module', ['test','module','educational'])
322        man = doc.getElementsByTagName('manifest')
323        md = man[0].getElementsByTagName('metadata')
324        sch = md[0].getElementsByTagName('schema')
325        ver = md[0].getElementsByTagName('version')
326        lom = md[0].getElementsByTagNameNS(LOM_IMSCC_namespace, 'lom')
327        gen = lom[0].getElementsByTagName('general')
328        ident = gen[0].getElementsByTagName('identifier')
329        cat = ident[0].getElementsByTagName('catalog')
330        entry = ident[0].getElementsByTagName('entry')
331        tn = gen[0].getElementsByTagName('title')
332        tnstr = tn[0].getElementsByTagName('string')
333        lang = gen[0].getElementsByTagName('language')
334        dn = gen[0].getElementsByTagName('description')
335        dnstr = dn[0].getElementsByTagName('string')
336        kn = gen[0].getElementsByTagName('keyword')
337        knstrs = kn[0].getElementsByTagName('string')
338        kws = [kw.childNodes[0].nodeValue for kw in knstrs]
339        schval = sch[0].childNodes[0].nodeValue
340        verval = ver[0].childNodes[0].nodeValue
341        catval = cat[0].childNodes[0].nodeValue
342        entryval = entry[0].childNodes[0].nodeValue
343        tnstrval = tnstr[0].childNodes[0].nodeValue
344        langval = lang[0].childNodes[0].nodeValue
345        dnstrval = dnstr[0].childNodes[0].nodeValue
346        self.assertEqual(schval, 'IMS Common Cartridge')
347        self.assertEqual(verval, '1.0.0')
348        self.assertEqual(catval, 'http://plone.org')
349        self.assertEqual(entryval, '001')
350        self.assertEqual(tnstrval, 'Test Module')
351        self.assertEqual(langval, 'en')
352        self.assertEqual(dnstrval, 'This is a test module')
353        self.assertEqual(kws, ['test', 'module', 'educational'])
354
355    def testCreateOrganizations(self):
356        """ Test for writing of organizations, organization, and shell item elements """
357        ccw = CCWriter()
358        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
359        man = doc.getElementsByTagName('manifest')
360        ccw.createOrganizations(doc, 'org001', 'item001')
361        man = doc.getElementsByTagName('manifest')
362        orgs = man[0].getElementsByTagName('organizations')
363        org = orgs[0].getElementsByTagName('organization')
364        item = org[0].getElementsByTagName('item')
365        orgid = org[0].getAttribute('identifier')
366        struct = org[0].getAttribute('structure')
367        itemid = item[0].getAttribute('identifier')
368        self.assertEqual(orgid, 'org001')
369        self.assertEqual(struct, 'rooted-hierarchy')
370        self.assertEqual(itemid, 'item001')
371
372    def testCreateResources(self):
373        """ Test for writing of resources element """
374        ccw = CCWriter()
375        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
376        ccw.createResources(doc)
377        man = doc.getElementsByTagName('manifest')
378        resources = man[0].getElementsByTagName('resources')
379        assert(resources)
380       
381    def testWriteItem(self):
382        """ Test for writing of a single element """
383        ccw = CCWriter()
384        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
385        ccw.createOrganizations(doc, 'org001', 'item001')
386        orgs = doc.getElementsByTagName('organizations')
387        title = ccw.writeItem(orgs[0], 'item002', 'res002', 'This is a test item')
388        itn = orgs[0].getElementsByTagName('item')
389        # Get the last item added and verify attributes
390        itemid = itn[-1].getAttribute('identifier')
391        refid = itn[-1].getAttribute('identifierref')
392        tnstr = title.childNodes[0].nodeValue
393        self.assertEqual(itemid, 'item002')
394        self.assertEqual(refid, 'res002')
395        self.assertEqual(tnstr, 'This is a test item')
396
397    def testWriteResource(self):
398        """ Test for single of resource element """
399        ccw = CCWriter()
400        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
401        res = ccw.createResources(doc)
402        rn1 = ccw.writeResource(res, 'res002', 'Link', 'test-module/test.gif')
403        rn2 = ccw.writeResource(res, 'res003', 'Document', 'test-module/index.html')
404        idval1 = rn1.getAttribute('identifier')
405        typeval1 = rn1.getAttribute('type')
406        hrefval1 = rn1.getAttribute('href')       
407        idval2 = rn2.getAttribute('identifier')
408        typeval2 =  rn2.getAttribute('type')
409        hrefval2 = rn2.getAttribute('href')
410        self.assertEqual(idval1, 'res002')
411        self.assertEqual(typeval1, 'imswl_xmlv1p0')
412        self.assertEqual(hrefval1, '')
413        self.assertEqual(idval2, 'res003')
414        self.assertEqual(typeval2, 'webcontent')
415        self.assertEqual(hrefval2, 'test-module/index.html')
416
417    def testCreateResourceMetadata(self):
418        """ Test for writing of resource metadata """
419        ccw = CCWriter()
420        doc = ccw.createManifest('001', '2009-05-12 15:07:34')
421        res = ccw.createResources(doc)
422        LOM_namespace = 'http://ltsc.ieee.org/xsd/LOM'
423        res = ccw.createResources(doc)
424        rn = ccw.writeResource(res, 'res001', 'Document', 'test-module/test-doc.html')
425        ccw.createResourceMetadata(rn)
426        mdn = rn.getElementsByTagName('metadata')
427        lom = mdn[0].getElementsByTagNameNS(LOM_namespace, 'lom')
428        assert(lom)
429
430    def testWriteGeneralNode(self):
431        """ Test for writing of general node """
432        ccw = CCWriter()
433        lom = minidom.Document()
434        ccw.writeGeneralNode(lom, 'res001', 'Resource 001', 'http://www.plone.org', 'en', 'Test item number 001', ['test', 'module', 'educational'])
435        gen = lom.getElementsByTagName('general')
436        idn = gen[0].getElementsByTagName('identifier')
437        cat = idn[0].getElementsByTagName('catalog')
438        ent = idn[0].getElementsByTagName('entry')
439        tn = gen[0].getElementsByTagName('title')
440        tnstr = tn[0].getElementsByTagName('string')
441        lang = gen[0].getElementsByTagName('language')
442        dn = gen[0].getElementsByTagName('description')
443        dnstr = dn[0].getElementsByTagName('string')
444        kn = gen[0].getElementsByTagName('keyword')
445        knstrs = kn[0].getElementsByTagName('string')
446        kws = [kw.childNodes[0].nodeValue for kw in knstrs]
447        entval = ent[0].childNodes[0].nodeValue
448        tnstrval = tnstr[0].childNodes[0].nodeValue
449        catval = cat[0].childNodes[0].nodeValue
450        langval = lang[0].childNodes[0].nodeValue
451        dnstrval = dnstr[0].childNodes[0].nodeValue
452        self.assertEqual(entval,'res001')
453        self.assertEqual(tnstrval,'Resource 001')
454        self.assertEqual(catval,'http://www.plone.org')
455        self.assertEqual(langval,'en')
456        self.assertEqual(dnstrval,'Test item number 001')
457        self.assertEqual(kws,['test', 'module', 'educational'])
458
459
460    def testWriteLifeCycleNode(self):
461        """ Test for writing life cycle node """
462        ccw = CCWriter()
463        lom = minidom.Document()
464        ccw.writeLifeCycleNode(lom, ['test-creator1', 'Test creator2'], ['test-contributor1', 'Test Contributor2'], '2009-05-12 15:07:34', 'en')
465        ln = lom.getElementsByTagName('lifeCycle')
466        an = ln[0].getElementsByTagName('contribute')
467        assert(ln)
468        self.assertEqual(len(an), 2)
469
470    def testWriteMetaMetadata(self):
471        """ Test for metaMetadata node """
472        ccw = CCWriter()
473        lom = minidom.Document()       
474        ccw.writeMetaMetadataNode(lom, 'res001', 'http://www.enpraxis.net', 'user@enpraxis.net', '2009-05-12 15:07:34', 'en', ['test-contributor1', 'Test Contributor2'])
475        mmdn = lom.getElementsByTagName('metaMetadata')
476        idn = mmdn[0].getElementsByTagName('identifier')
477        cat = idn[0].getElementsByTagName('catalog')
478        ent = idn[0].getElementsByTagName('entry')
479        mdsc = mmdn[0].getElementsByTagName('metadataSchema')       
480        lang = mmdn[0].getElementsByTagName('language')
481        cont = mmdn[0].getElementsByTagName('contribute')
482        catval = cat[0].childNodes[0].nodeValue
483        entval = ent[0].childNodes[0].nodeValue
484        mdscval = mdsc[0].childNodes[0].nodeValue
485        langval = lang[0].childNodes[0].nodeValue
486        self.assertEqual(catval, 'http://www.enpraxis.net,user@enpraxis.net')
487        self.assertEqual(entval, 'res001')
488        self.assertEqual(mdscval, 'LOMv1.0')
489        self.assertEqual(langval, 'en')
490        self.assertEqual(len(cont), 1)
491
492    def testWriteTechnical(self):
493        """ Test for writing of technical node """
494        ccw = CCWriter()
495        lom = minidom.Document()
496        ccw.writeTechnicalNode(lom, 'text/html', '22', 'http://enpraxis.net/course/test-file.html')
497        techn = lom.getElementsByTagName('technical')
498        fmn = techn[0].getElementsByTagName('format')
499        sn = techn[0].getElementsByTagName('size')
500        lcn = techn[0].getElementsByTagName('location')
501        fmnval = fmn[0].childNodes[0].nodeValue
502        snval = sn[0].childNodes[0].nodeValue
503        lcnval = lcn[0].childNodes[0].nodeValue
504        self.assertEqual(fmnval, 'text/html')
505        self.assertEqual(snval, '22')
506        self.assertEqual(lcnval, 'http://enpraxis.net/course/test-file.html')
507
508    def testWriteRights(self):
509        """ Test for writing of rights node """
510        ccw = CCWriter()
511        lom = minidom.Document()
512        ccw.writeRightsNode(lom, 'yes', 'Description of test document 001', 'en')
513        rights = lom.getElementsByTagName('rights')
514        crn = rights[0].getElementsByTagName('copyrightAndOtherRestrictions')
515        sn = crn[0].getElementsByTagName('source')
516        val = crn[0].getElementsByTagName('value')
517        dn = rights[0].getElementsByTagName('description')
518        dnstr = dn[0].getElementsByTagName('string')
519        lang = dnstr[0].getAttribute('xml:lang')
520        snval = sn[0].childNodes[0].nodeValue
521        valval = val[0].childNodes[0].nodeValue
522        dnstrval = dnstr[0].childNodes[0].nodeValue
523        self.assertEqual(snval, 'LOMv1.0')
524        self.assertEqual(valval, 'yes')
525        self.assertEqual(dnstrval, 'Description of test document 001')
526        self.assertEqual(lang, 'en')
527
528    def testCreateContributeElement(self):
529        """ Test for writing of contribute element """
530        ccw = CCWriter()
531        doc = minidom.Document()
532        LOM_version = 'LOMv1.0'
533        ccw._createContributeElement(doc, 'http://enpraxis.net', LOM_version, 'unknown', entities=['test', 'test creator', 'Test creator'], date='2009-05-12 15:07:34', email='user@enpraxis.net')
534        con = doc.getElementsByTagNameNS('http://enpraxis.net','contribute')
535        rn = doc.getElementsByTagName('role')
536        val = rn[0].getElementsByTagName('value')
537        sn = rn[0].getElementsByTagName('source')
538        ent = con[0].getElementsByTagName('entity')
539        dtn = con[0].getElementsByTagName('date')
540        dttn = dtn[0].getElementsByTagName('dateTime')       
541        valval = val[0].childNodes[0].nodeValue
542        snval = sn[0].childNodes[0].nodeValue
543        dttnval = dttn[0].childNodes[0].nodeValue
544        self.assertEqual(valval, 'unknown')
545        self.assertEqual(snval, 'LOMv1.0')
546        self.assertEqual(dttnval, '2009-05-12 15:07:34')
547        self.assertEqual(len(ent), 3)
548
549    def testCreateVCard(self):
550        """ Test creating of VCard element """
551        ccw = CCWriter()
552        vcard = ccw._createVCard('Test User', 'test-user@enpraxis.net')
553        self.assertNotEqual(vcard.find('BEGIN:VCARD\n'), -1)
554        self.assertNotEqual(vcard.find('FN:Test User'), -1)
555        self.assertNotEqual(vcard.find('EMAIL;INTERNET:test-user@enpraxis.net'), -1)
556        self.assertNotEqual(vcard.find('END:VCARD'), -1)
557
558    def testWriteResourceFile(self):
559        """ Test writing of resource file """
560        ccw = CCWriter()
561        doc = minidom.Document()
562        ccw.writeResourceFile(doc, 'test-module/test-doc.html')
563        files = doc.getElementsByTagName('file')
564        href = files[0].getAttribute('href')
565        self.assertEqual(href, 'test-module/test-doc.html')
566
567    def testGetManifest(self):
568        """ Test getting of manifest element """
569        ccw = CCWriter()
570        doc = ccw.createManifest('008', '2009-06-12 12:00:00')
571        man = ccw.getManifest(doc)
572        # Check some of the mainfest attributes
573        mn = minidom.parseString(man)
574        manifest = mn.getElementsByTagName('manifest')
575        idval = manifest[0].getAttribute('identifier')
576        verval = manifest[0].getAttribute('xmlns:version')
577        nsval = manifest[0].getAttribute('xmlns')
578        xsival = manifest[0].getAttribute('xsi:schemaLocation')
579        self.assertEqual(idval, '008')
580        self.assertEqual(verval, '2009-06-12 12:00:00')
581        self.assertEqual(nsval, 'http://www.imsglobal.org/xsd/imscc/imscp_v1p1')
582        self.assertNotEqual(xsival.find('http://www.imsglobal.org/xsd/imscc/imscp_v1p1'), -1)
583
584    def testCreateNode(self):
585        """ Test creating of individual node """
586        ccw = CCWriter()
587        doc = minidom.Document()
588        tstn = ccw._createNode(doc, 'http://www.enpraxis.net', 'test', '')
589        self.assertEqual(tstn.toxml(), '<test xmlns="http://www.enpraxis.net"/>')
590        doc = minidom.Document()
591        tstn = ccw._createNode(doc, 'http://www.enpraxis.net', 'test', 'test string')
592        tstnval = tstn.childNodes[0].nodeValue
593        self.assertEqual(tstnval, 'test string')
594        self.assertEqual(type(tstnval), type(u''))
595        doc = minidom.Document()
596        tstn = ccw._createNode(doc, 'http://www.enpraxis.net', 'test', '', attrs=[('testid','009'),('href','test-course/test-doc.html')])
597        self.assertEqual(tstn.getAttribute('testid'), '009')
598        self.assertEqual(tstn.getAttribute('href'), 'test-course/test-doc.html')
599
600    def testAddNamespaces(self):
601        """ Testing of the adding of namespaces """
602        ccw = CCWriter()
603        doc = minidom.Document()
604        tn = doc.createElement('test')
605        doc.appendChild(tn)
606        namespaces = [('xmlns', 'http://enpraxis.net'),
607              ('xmlns:plone','http://plone.org'),]
608        ccw.addNamespaces(tn, namespaces)
609        self.assertEqual(tn.getAttribute('xmlns'), 'http://enpraxis.net')
610        self.assertEqual(tn.getAttribute('xmlns:plone'), 'http://plone.org')
611   
612    def testGetTextValue(self):
613        """ Test getting a text value from a node """
614        ccw = CCWriter()
615        doc = minidom.Document()
616        newnode = doc.createElement('test')
617        doc.appendChild(newnode)
618        newnode.appendChild(doc.createTextNode(u'Test node text'))
619        self.assertEqual(ccw.getTextValue(newnode), 'Test node text')
620        # Test without any text node present
621        doc = minidom.Document()
622        newnode = doc.createElement('test1')
623        doc.appendChild(newnode)
624        self.assertEqual(ccw.getTextValue(newnode), None)
625        # Test with extra space
626        doc = minidom.Document()
627        newnode = doc.createElement('test1')
628        doc.appendChild(newnode)
629        newnode.appendChild(doc.createTextNode(u'   Test node text  \n'))
630        self.assertEqual(ccw.getTextValue(newnode), 'Test node text')
631
632    def testGetLinkXml(self):
633        """ Test link xml """
634        ccw = CCWriter()
635        WL_namespace = 'http://www.imsglobal.org/xsd/imswl_v1p0'
636        link = ccw.getLinkXml('Plone', 'http://www.plone.org')
637        doc = minidom.parseString(link)
638        wls = doc.getElementsByTagNameNS(WL_namespace, 'webLink')
639        tn = wls[0].getElementsByTagName('title')
640        url = wls[0].getElementsByTagName('url')
641        tnval = tn[0].childNodes[0].nodeValue
642        urlval = url[0].getAttribute('href')
643        self.assertEqual(tnval, 'Plone')
644        self.assertEqual(urlval, 'http://www.plone.org')
645
646def test_suite():
647    suite = TestSuite()
648    suite.addTest(makeSuite(TestCCReader))
649    suite.addTest(makeSuite(TestCCWriter))
650    return suite
Note: See TracBrowser for help on using the repository browser.