def test_xml_to_dict_multiple_records(self):
        """Test the xml to dict function."""
        topics_xml = '''<topics type="array">
            <topic>
              <title>The First Topic</title>
              <author-name>David</author-name>
              <id type="integer">1</id>
              <approved type="boolean">false</approved>
              <replies-count type="integer">0</replies-count>
              <replies-close-in type="integer">2592000000</replies-close-in>
              <written-on type="date">2003-07-16</written-on>
              <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
              <content>Have a nice day</content>
              <author-email-address>[email protected]</author-email-address>
              <parent-id nil="true"></parent-id>
            </topic>
            <topic>
              <title>The Second Topic</title>
              <author-name>Jason</author-name>
              <id type="integer">1</id>
              <approved type="boolean">false</approved>
              <replies-count type="integer">0</replies-count>
              <replies-close-in type="integer">2592000000</replies-close-in>
              <written-on type="date">2003-07-16</written-on>
              <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
              <content>Have a nice day</content>
              <author-email-address>[email protected]</author-email-address>
              <parent-id></parent-id>
            </topic>
          </topics>'''

        expected_topic_dict = {
          'title': 'The First Topic',
          'author_name': 'David',
          'id': 1,
          'approved': False,
          'replies_count': 0,
          'replies_close_in': 2592000000,
          'written_on': datetime.date(2003, 7, 16),
          'viewed_at': util.date_parse('2003-07-16T09:28Z'),
          'content': 'Have a nice day',
          'author_email_address': '[email protected]',
          'parent_id': None}

        self.assertEqual(expected_topic_dict,
                         util.xml_to_dict(topics_xml, saveroot=False)[0])
        self.assertEqual(
                expected_topic_dict,
                util.xml_to_dict(topics_xml, saveroot=True)['topics'][0])

 def test_xml_to_dict_parses_datetime_timezones(self):
     blog_xml = '''<blog>
         <posted_at type="datetime">2008-09-05T13:34-0700</posted_at>
       </blog>'''
     blog_dict = util.xml_to_dict(blog_xml, saveroot=True)
     self.assertEqual((2008, 9, 5, 20, 34, 0, 4, 249, 0),
                      blog_dict['blog']['posted_at'].utctimetuple())

 def test_xml_to_dict_empty_array(self):
     blog_xml = '''<blog>
         <posts type="array"></posts>
         </blog>'''
     expected_blog_dict = {'blog': {'posts': []}}
     self.assertEqual(expected_blog_dict,
                      util.xml_to_dict(blog_xml, saveroot=True))

    def test_xml_to_dict_multiple_records_with_different_types(self):
        """Test the xml to dict function."""
        topics_xml = '''<topics type="array">
            <topic>
              <title>The First Topic</title>
              <author-name>David</author-name>
              <id type="integer">1</id>
              <approved type="boolean">false</approved>
              <replies-count type="integer">0</replies-count>
              <replies-close-in type="integer">2592000000</replies-close-in>
              <written-on type="date">2003-07-16</written-on>
              <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
              <content>Have a nice day</content>
              <author-email-address>[email protected]</author-email-address>
              <parent-id nil="true"></parent-id>
            </topic>
            <topic type='SubTopic'>
              <title>The Second Topic</title>
              <author-name>Jason</author-name>
              <id type="integer">1</id>
              <approved type="boolean">false</approved>
              <replies-count type="integer">0</replies-count>
              <replies-close-in type="integer">2592000000</replies-close-in>
              <written-on type="date">2003-07-16</written-on>
              <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
              <content>Have a nice day</content>
              <author-email-address>[email protected]</author-email-address>
              <parent-id></parent-id>
            </topic>
          </topics>'''

        parsed = util.xml_to_dict(topics_xml, saveroot=False)
        self.assertEqual('topics', parsed.element_type)
        self.assertEqual('topic', parsed[0].element_type)
        self.assertEqual('sub_topic', parsed[1].element_type)

 def test_to_xml_should_handle_attributes_containing_lists_of_dicts(self):
     children = [{'name': 'child1'}, {'name': 'child2'}]
     res = activeresource.ActiveResource()
     res.children = children
     xml = res.to_xml()
     parsed = util.xml_to_dict(xml, saveroot=False)
     self.assertEqual(children, parsed['children'])

 def test_xml_to_dict_parses_children_which_are_not_of_parent_type(self):
     product_xml = '''
       <products type="array">
         <shamwow><made-in>Germany</made-in></shamwow>
       </products>'''
     self.assertEqual({'products': [{'made_in': 'Germany'}]},
                      util.xml_to_dict(product_xml, saveroot=True))

 def decode(resource_string):
     """Convert a resource string to a dictionary."""
     log = logging.getLogger('pyactiveresource.format')
     log.debug('decoding resource: %s', resource_string)
     try:
         data = util.xml_to_dict(resource_string, saveroot=False)
     except util.Error, err:
         raise Error(err)

 def test_xml_to_dict_should_parse_dictionaries_with_unknown_types(self):
     xml = '''<records type="array">
                <record type="MiscData">
                  <name>misc_data1</name>
                </record>
              </records>'''
     expected = {'records': [{'type': 'MiscData', 'name': 'misc_data1'}]}
     self.assertEqual(expected, util.xml_to_dict(xml, saveroot=True))

 def test_xml_to_dict_array_with_one_entry(self):
     blog_xml = '''<blog>
         <posts type="array">
           <post>a post</post>
         </posts>
       </blog>'''
     expected_blog_dict = {'blog': {'posts': ['a post']}}
     self.assertEqual(expected_blog_dict,
                      util.xml_to_dict(blog_xml, saveroot=True))

 def test_xml_to_dict_unknown_type(self):
     product_xml = '''<product>
         <weight type="double">0.5</weight>
         <image type="ProductImage"><filename>image.gif</filename></image>
        </product>'''
     expected_product_dict = {
         'weight': 0.5,
         'image': {'type': 'ProductImage', 'filename': 'image.gif'}}
     self.assertEqual(
             expected_product_dict,
             util.xml_to_dict(product_xml, saveroot=True)['product'])

 def test_xml_to_dict_file_with_defaults(self):
     blog_xml = '''<blog>
         <logo type="file">
         </logo>
       </blog>'''
     blog_dict = util.xml_to_dict(blog_xml, saveroot=True)
     self.assert_('blog' in blog_dict)
     self.assert_('logo' in blog_dict['blog'])
     blog_file = blog_dict['blog']['logo']
     self.assertEqual('untitled', blog_file.name)
     self.assertEqual('application/octet-stream', blog_file.content_type)

 def test_xml_to_dict_file(self):
     blog_xml = '''<blog>
         <logo type="file" name="logo.png" content_type="image/png">
         </logo>
       </blog>'''
     blog_dict = util.xml_to_dict(blog_xml, saveroot=True)
     self.assert_('blog' in blog_dict)
     self.assert_('logo' in blog_dict['blog'])
     blog_file = blog_dict['blog']['logo']
     self.assertEqual('logo.png', blog_file.name)
     self.assertEqual('image/png', blog_file.content_type)

 def decode(resource_string):
     """Convert a resource string to a dictionary."""
     log = logging.getLogger('pyactiveresource.format')
     log.debug('decoding resource: %s', resource_string)
     try:
         data = util.xml_to_dict(resource_string, saveroot=False)
     except util.Error as err:
         raise Error(err)
     if isinstance(data, dict) and len(data) == 1:
         data = iter(data.values())[0]
     return data

    def test_xml_to_dict_single_record(self):
        """Test the xml_to_dict function."""
        topic_xml = '''<topic>
             <title>The First Topic</title>
             <author-name>David</author-name>
             <id type="integer">1</id>
             <approved type="boolean"> true </approved>
             <replies-count type="integer">0</replies-count>
             <replies-close-in type="integer">2592000000</replies-close-in>
             <written-on type="date">2003-07-16</written-on>
             <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
             <content type="yaml">--- \n1: should be an integer\n:message: Have a nice day\narray: \n- should-have-dashes: true\n  should_have_underscores: true\n</content>
             <author-email-address>[email protected]</author-email-address>
             <parent-id></parent-id>
             <ad-revenue type="decimal">1.5</ad-revenue>
             <optimum-viewing-angle type="float">135</optimum-viewing-angle>
             <resident type="symbol">yes</resident>
           </topic>'''

        expected_topic_dict = {
            'title': 'The First Topic',
            'author_name': 'David',
            'id': 1,
            'approved': True,
            'replies_count': 0,
            'replies_close_in': 2592000000,
            'written_on': datetime.date(2003, 7, 16),
            'viewed_at': util.date_parse('2003-07-16T9:28Z'),
            'content': {':message': 'Have a nice day',
                        1: 'should be an integer',
                        'array': [{'should-have-dashes': True,
                                   'should_have_underscores': True}]},
            'author_email_address': '[email protected]',
            'parent_id': None,
            'ad_revenue': decimal.Decimal('1.5'),
            'optimum_viewing_angle': 135.0,
            'resident': 'yes'}

        self.assertEqual(expected_topic_dict, util.xml_to_dict(topic_xml, saveroot=False))
        self.assertEqual(expected_topic_dict,
                         util.xml_to_dict(topic_xml)['topic'])

    def test_should_be_able_to_add_note_attributes_to_an_order(self):
        order = shopify.Order()
        order.note_attributes = []
        order.note_attributes.append(shopify.NoteAttribute({'name': "color", 'value': "blue"}))

        order_xml = xml_to_dict(order.to_xml())
        note_attributes = order_xml["order"]["note_attributes"]
        self.assertTrue(isinstance(note_attributes, list))

        attribute = note_attributes[0]
        self.assertEqual("color", attribute["name"])
        self.assertEqual("blue", attribute["value"])

 def test_to_xml_should_consider_attributes_on_element_with_children(self):
     custom_field_xml = '''
         <custom_field name="custom1" id="1">
           <value>cust1</value>
         </custom_field>'''
     expected = {
             'custom_field': {
                 'name': 'custom1',
                 'id': '1',
                 'value': 'cust1'}
             }
     result = util.xml_to_dict(custom_field_xml, saveroot=True)
     self.assertEqual(expected, result)

    def from_xml(self, xml_string):
        """Grab errors from an XML response.

        Args:
            xml_string: An xml errors object (e.g. '<errors></errors>')
        Returns:
            None
        """
        try:
            messages = util.xml_to_dict(xml_string)["errors"]["error"]
            if not isinstance(messages, list):
                messages = [messages]
        except util.Error:
            messages = []
        self.from_array(messages)

    def test_should_be_loaded_correctly_from_order_xml(self):
        order_xml = """<?xml version="1.0" encoding="UTF-8"?>
          <order>
            <note-attributes type="array">
              <note-attribute>
                <name>size</name>
                <value>large</value>
              </note-attribute>
            </note-attributes>
          </order>"""
        order = shopify.Order(xml_to_dict(order_xml)["order"])

        self.assertEqual(1, len(order.note_attributes))

        note_attribute = order.note_attributes[0]
        self.assertEqual("size", note_attribute.name)
        self.assertEqual("large", note_attribute.value)

    def test_xml_to_dict_xsd_like_types(self):
        bacon_xml = '''<bacon>
            <weight type="double">0.5</weight>
            <price type="decimal">12.50</price>
            <chunky type="boolean"> 1 </chunky>
            <expires-at type="dateTime">2007-12-25T12:34:56+0000</expires-at>
            <notes type="string"></notes>
            <illustration type="base64Binary">YmFiZS5wbmc=</illustration>
            </bacon>'''
        expected_bacon_dict = {
            'weight': 0.5,
            'chunky': True,
            'price': decimal.Decimal('12.50'),
            'expires_at': util.date_parse('2007-12-25T12:34:56Z'),
            'notes': '',
            'illustration': b'babe.png'}

        self.assertEqual(expected_bacon_dict,
                         util.xml_to_dict(bacon_xml, saveroot=True)['bacon'])

    def from_xml(self, xml_string):
        """Grab errors from an XML response.

        Args:
            xml_string: An xml errors object (e.g. '<errors></errors>')
        Returns:
            None
        """
        attribute_keys = self.base.attributes.keys()
        try:
            messages = util.xml_to_dict(xml_string)["errors"]["error"]
            if not isinstance(messages, list):
                messages = [messages]
        except util.Error:
            messages = []
        for message in messages:
            attr_name = message.split()[0]
            key = util.underscore(attr_name)
            if key in attribute_keys:
                self.add(key, message[len(attr_name) + 1 :])
            else:
                self.add_to_base(message)