Added unit tests for character encoding combinations used in the v2 atom core.

j.s@google.com · j.s@google.com · commit 85abe7451edc · 2009-04-18T01:56:55.000Z
diff --git a/src/atom/core.py b/src/atom/core.py
@@ -35,7 +35,14 @@
       from elementtree import ElementTree
 
 
+STRING_ENCODING = 'utf-8'
+
+
 class XmlElement(object):
+  """Represents an element node in an XML document.
+  
+  The text member is a UTF-8 encoded str.
+  """
   _qname = None
   _other_elements = None
   _other_attributes = None
@@ -243,12 +250,12 @@ def _harvest_tree(self, tree, version=1):
     if tree.text:
       self.text = tree.text
 
-  def _to_tree(self, version=1):
+  def _to_tree(self, version=1, encoding=None):
     new_tree = ElementTree.Element(_get_qname(self, version))
-    self._attach_members(new_tree, version)
+    self._attach_members(new_tree, version, encoding)
     return new_tree
 
-  def _attach_members(self, tree, version=1):
+  def _attach_members(self, tree, version=1, encoding=None):
     """Convert members to XML elements/attributes and add them to the tree.
     
     Args:
@@ -282,11 +289,16 @@ def _attach_members(self, tree, version=1):
     for key, value in self._other_attributes.iteritems():
       tree.attrib[key] = value
     if self.text:
-      tree.text = self.text
+      if isinstance(self.text, unicode):
+        tree.text = self.text
+      elif encoding is not None:
+        tree.text = self.text.decode(encoding)
+      else:
+        tree.text = self.text.decode(STRING_ENCODING)
 
-  def to_string(self, version=1):
+  def to_string(self, version=1, encoding=None):
     """Converts this object to XML."""
-    return ElementTree.tostring(self._to_tree(version))
+    return ElementTree.tostring(self._to_tree(version, encoding))
 
   ToString = to_string
 
@@ -356,7 +368,7 @@ def _qname_matches(tag, namespace, qname):
 
 
 def xml_element_from_string(xml_string, target_class, 
-    version=1, encoding='UTF-8'):
+    version=1, encoding=None):
   """Parses the XML string according to the rules for the target_class.
 
   Args:
@@ -365,6 +377,11 @@ def xml_element_from_string(xml_string, target_class,
     version: int (optional) The version of the schema which should be used when
              converting the XML into an object. The default is 1.
   """
+  if isinstance(xml_string, unicode):
+    if encoding is None:
+      xml_string = xml_string.encode(STRING_ENCODING)
+    else:
+      xml_string = xml_string.encode(encoding)
   tree = ElementTree.fromstring(xml_string)
   return _xml_element_from_tree(tree, target_class, version)
 
diff --git a/tests/atom_tests/core_test.py b/tests/atom_tests/core_test.py
@@ -303,9 +303,97 @@ def testMatchQnames(self):
         'foo', '', 'bar') == False)
 
 
+class Chars(atom.core.XmlElement):
+  _qname = u'{http://example.com/}chars'
+  y = 'y'
+  alpha = 'a'
+
+
+class Strs(atom.core.XmlElement):
+  _qname = '{http://example.com/}strs'
+  chars = [Chars]
+  delta = u'd'
+
+
+def parse(string):
+  return atom.core.xml_element_from_string(string, atom.core.XmlElement)
+
+
+def create(tag, string):
+  element = atom.core.XmlElement(text=string)
+  element._qname = tag
+  return element
+
+
+class CharacterEncodingTest(unittest.TestCase):
+
+  def testUnicodeInputString(self):
+    # Test parsing the inner text.
+    self.assertEqual(parse(u'<x>&#948;</x>').text, u'\u03b4')
+    self.assertEqual(parse(u'<x>\u03b4</x>').text, u'\u03b4')
+
+    # Test output valid XML.
+    self.assertEqual(parse(u'<x>&#948;</x>').to_string(), '<x>&#948;</x>')
+    self.assertEqual(parse(u'<x>\u03b4</x>').to_string(), '<x>&#948;</x>')
+
+    # Test setting the inner text and output valid XML.
+    e = create(u'x', u'\u03b4')
+    self.assertEqual(e.to_string(), '<x>&#948;</x>')
+    self.assertEqual(e.text, u'\u03b4')
+    self.assertTrue(isinstance(e.text, unicode))
+    self.assertEqual(create(u'x', '\xce\xb4'.decode('utf-8')).to_string(),
+                     '<x>&#948;</x>')
+
+
+  def testUtf8InputString(self):
+    # Test parsing inner text.
+    self.assertEqual(parse('<x>&#948;</x>').text, u'\u03b4')
+    self.assertEqual(parse(u'<x>\u03b4</x>'.encode('utf-8')).text, u'\u03b4')
+    self.assertEqual(parse('<x>\xce\xb4</x>').text, u'\u03b4')
+
+    # Test output valid XML.
+    self.assertEqual(parse('<x>&#948;</x>').to_string(), '<x>&#948;</x>')
+    self.assertEqual(parse(u'<x>\u03b4</x>'.encode('utf-8')).to_string(),
+                     '<x>&#948;</x>')
+    self.assertEqual(parse('<x>\xce\xb4</x>').to_string(), '<x>&#948;</x>')
+
+    # Test setting the inner text and output valid XML.
+    e = create('x', '\xce\xb4')
+    self.assertEqual(e.to_string(), '<x>&#948;</x>')
+    # Don't change the encoding until the we convert to an XML string.
+    self.assertEqual(e.text, '\xce\xb4')
+    self.assertTrue(isinstance(e.text, str))
+    self.assertTrue(isinstance(e.to_string(), str))
+    self.assertEqual(create('x', u'\u03b4'.encode('utf-8')).to_string(),
+                     '<x>&#948;</x>')
+
+
+
+  def testOtherEncodingOnInputString(self):
+    # Test parsing inner text.
+    self.assertEqual(parse(u'<x>\u03b4</x>'.encode('utf-16')).text, u'\u03b4')
+
+    # Test output valid XML.
+    self.assertEqual(parse(u'<x>\u03b4</x>'.encode('utf-16')).to_string(),
+                     '<x>&#948;</x>')
+
+    # Test setting the inner text and output valid XML.
+    e = create('x', u'\u03b4'.encode('utf-16'))
+    self.assertEqual(e.to_string(encoding='utf-16'), '<x>&#948;</x>')
+    # Don't change the encoding until the we convert to an XML string.
+    self.assertEqual(e.text, '\xff\xfe\xb4\x03')
+    self.assertTrue(isinstance(e.text, str))
+    self.assertTrue(isinstance(e.to_string(encoding='utf-16'), str))
+    self.assertEqual(
+        create('x', '\xff\xfe\xb4\x03').to_string(encoding='utf-16'),
+        '<x>&#948;</x>')
+    
+
+
 def suite():
   return unittest.TestSuite((unittest.makeSuite(XmlElementTest, 'test'),
-                             unittest.makeSuite(UtilityFunctionTest, 'test')))
+                             unittest.makeSuite(UtilityFunctionTest, 'test'),
+                             unittest.makeSuite(CharacterEncodingTest, 'test'),))
 
 
 if __name__ == '__main__':
