Added methods and unit tests for Blogger v2 client. Also corrected XML parsing logic when looking for a v2 XML element inside of a non-versioned XML element.

j.s@google.com · j.s@google.com · commit 5272dd41b50d · 2009-06-26T22:09:25.000Z
diff --git a/src/atom/core.py b/src/atom/core.py
@@ -272,12 +272,13 @@ def _harvest_tree(self, tree, version=1):
           if getattr(self, definition[0]) is None:
             setattr(self, definition[0], [])
           getattr(self, definition[0]).append(_xml_element_from_tree(element,
-              definition[1]))
+              definition[1], version))
         else:
           setattr(self, definition[0], _xml_element_from_tree(element, 
-              definition[1]))
+              definition[1], version))
       else:
-        self._other_elements.append(_xml_element_from_tree(element, XmlElement))
+        self._other_elements.append(_xml_element_from_tree(element, XmlElement,
+                                                           version))
     for attrib, value in tree.attrib.iteritems():
       if attributes and attrib in attributes:
         setattr(self, attributes[attrib], value)
diff --git a/src/gdata/blogger/client.py b/src/gdata/blogger/client.py
@@ -15,14 +15,19 @@
 # limitations under the License.
 
 
-"""Contains a client to communicate with the Blogger servers."""
+"""Contains a client to communicate with the Blogger servers.
+
+For documentation on the Blogger API, see:
+http://code.google.com/apis/blogger/
+"""
 
 
 __author__ = 'j.s@google.com (Jeff Scudder)'
 
 
 import gdata.client
-import gdata.data.blogger
+import gdata.blogger.data
+import atom.data
 
 
 # List user's blogs, takes a user ID, or 'default'.
@@ -36,6 +41,7 @@
 # Takes a blog ID.
 BLOG_ARCHIVE_URL = 'http://www.blogger.com/feeds/%s/archive/full'
 
+
 class BloggerClient(gdata.client.GDClient):
   api_version = '2'
   auth_serice = 'blogger'
@@ -46,3 +52,86 @@ def get_blogs(self, user_id='default', auth_token=None,
     return self.get_feed(BLOGS_URL % user_id, auth_token=auth_token,
                          desired_class=desired_class, **kwargs)
 
+  GetBlogs = get_blogs
+
+  def get_posts(self, blog_id, auth_token=None, 
+                desired_class=gdata.blogger.data.BlogPostFeed, query=None,
+                **kwargs):
+    return self.get_feed(BLOG_POST_URL % blog_id, auth_token=auth_token,
+                         desired_class=desired_class, query=query, **kwargs)
+
+  GetPosts = get_posts
+ 
+  def get_post_comments(self, blog_id, post_id,  auth_token=None, 
+                        desired_class=gdata.blogger.data.CommentFeed,
+                        query=None, **kwargs):
+    return self.get_feed(BLOG_POST_COMMENTS_URL % (blog_id, post_id),
+                         auth_token=auth_token, desired_class=desired_class,
+                         query=query, **kwargs)
+
+  GetPostComments = get_post_comments
+
+  def get_blog_comments(self, blog_id, auth_token=None,
+                        desired_class=gdata.blogger.data.CommentFeed,
+                        query=None, **kwargs):
+    return self.get_feed(BLOG_COMMENTS_URL % blog_id, auth_token=auth_token,
+                         desired_class=desired_class, query=query, **kwargs)
+
+  GetBlogComments = get_blog_comments
+
+  def get_blog_archive(self, blog_id, auth_token=None, **kwargs):
+    return self.get_feed(BLOG_ARCHIVE_URL % blog_id, auth_token=auth_token,
+                         **kwargs)
+
+  GetBlogArchive = get_blog_archive
+
+  def add_post(self, blog_id, title, body, labels=None, draft=False,
+               auth_token=None, title_type='text', body_type='html', **kwargs):
+    # Construct an atom Entry for the blog post to be sent to the server.
+    new_entry = gdata.blogger.data.BlogPost(
+        title=atom.data.Title(text=title, type=title_type),
+        content=atom.data.Content(text=body, type=body_type))
+    if labels:
+      for label in labels:
+        new_entry.add_label(label)
+    if draft:
+      new_entry.control = atom.data.Control(draft=atom.data.Draft(text='yes'))
+    print 'here is your new post:'
+    print str(new_entry)
+    return self.post(new_entry, BLOG_POST_URL % blog_id, auth_token=auth_token, **kwargs)
+
+  AddPost = add_post
+
+  def add_comment(self, blog_id, post_id, title, body, auth_token=None,
+                  title_type='text', body_type='html', **kwargs):
+    new_entry = gdata.blogger.data.Comment(
+        title=atom.data.Title(text=title, type=title_type),
+        content=atom.data.Content(text=body, type=body_type))
+    return self.post(new_entry, BLOG_POST_COMMENTS_URL % (blog_id, post_id),
+                     auth_token=auth_token, **kwargs)
+
+  AddComment = add_comment
+
+  def update(self, entry, auth_token=None, **kwargs):
+    # The Blogger API does not currently support ETags, so for now remove
+    # the ETag before performing an update.
+    old_etag = entry.etag
+    entry.etag = None
+    response = gdata.client.GDClient.update(self, entry,
+                                            auth_token=auth_token, **kwargs)
+    entry.etag = old_etag
+    return response
+
+  Update = update
+
+  def delete(self, entry, auth_token=None, **kwargs):
+    # The Blogger API does not currently support ETags, so for now remove
+    # the ETag before performing a delete.
+    old_etag = entry.etag
+    entry.etag = None
+    response = gdata.client.GDClient.delete(self, entry,
+                                            auth_token=auth_token, **kwargs)
+    entry.etag = old_etag
+    return response
+
+  Delete = delete
diff --git a/src/gdata/client.py b/src/gdata/client.py
@@ -140,6 +140,19 @@ def error_from_response(message, http_response, error_class, response_body=None)
   return error
 
 
+def get_xml_version(version):
+  """Determines which XML schema to use based on the client API version.
+  
+  Args:
+    version: string which is converted to an int. The version string is in
+             the form 'Major.Minor.x.y.z' and only the major version number
+             is considered. If None is provided assume version 1. 
+  """
+  if version is None:
+    return 1
+  return int(version.split('.')[0])
+
+
 class GDClient(atom.client.AtomPubClient):
   """Communicates with Google Data servers to perform CRUD operations.
 
@@ -276,7 +289,7 @@ def request(self, method=None, uri=None, auth_token=None,
       elif desired_class is not None:
         if self.api_version is not None:
           return atom.core.parse(response.read(), desired_class,
-                                 version=self.api_version)
+                                 version=get_xml_version(self.api_version))
         else:
           # No API version was specified, so allow parse to
           # use the default version.
@@ -484,7 +497,9 @@ def post(self, entry, uri, auth_token=None, converter=None,
     if converter is None and desired_class is None:
       desired_class = entry.__class__
     http_request = atom.http_core.HttpRequest()
-    http_request.add_body_part(entry.to_string(), 'application/atom+xml')
+    http_request.add_body_part(
+        entry.to_string(get_xml_version(self.api_version)),
+        'application/atom+xml')
     return self.request(method='POST', uri=uri, auth_token=auth_token,
                         http_request=http_request, converter=converter,
                         desired_class=desired_class, **kwargs)
@@ -511,7 +526,9 @@ def update(self, entry, auth_token=None, force=False, **kwargs):
       A new Entry object of a matching type to the entry which was passed in.
     """
     http_request = atom.http_core.HttpRequest()
-    http_request.add_body_part(entry.to_string(), 'application/atom+xml')
+    http_request.add_body_part(
+        entry.to_string(get_xml_version(self.api_version)),
+        'application/atom+xml')
     # Include the ETag in the request if this is version 2 of the API.
     if self.api_version and self.api_version.startswith('2'):
       if force:
diff --git a/tests/all_tests.py b/tests/all_tests.py
@@ -34,6 +34,7 @@
 import gdata_tests.live_client_test
 import gdata_tests.gauth_test
 import gdata_tests.blogger.data_test
+import gdata_tests.blogger.live_client_test
 # Compatibility tests for requests to v1 feeds.
 import gdata_tests.contacts.service_test
 # Tests for v1 classes.
@@ -52,14 +53,15 @@ def suite():
   return unittest.TestSuite((atom_tests.core_test.suite(),
                              atom_tests.data_test.suite(),
                              atom_tests.http_core_test.suite(),
+                             atom_tests.auth_test.suite(),
                              atom_tests.mock_http_core_test.suite(),
                              atom_tests.client_test.suite(),
-                             atom_tests.auth_test.suite(),
                              gdata_tests.client_test.suite(),
                              gdata_tests.data_test.suite(),
+                             gdata_tests.live_client_test.suite(),
                              gdata_tests.gauth_test.suite(),
                              gdata_tests.blogger.data_test.suite(),
-                             gdata_tests.live_client_test.suite(),
+                             gdata_tests.blogger.live_client_test.suite(),
                              gdata_tests.contacts.service_test.suite(),
                              atom_test.suite(), gdata_test.suite(),
                              atom_tests.service_test.suite(),
diff --git a/tests/all_tests_coverage.py b/tests/all_tests_coverage.py
@@ -32,6 +32,8 @@
 import gdata.gauth
 import gdata.client
 import gdata.data
+import gdata.blogger.data
+import gdata.blogger.client
 from gdata.test_config import settings
 
 
@@ -51,4 +53,4 @@ def suite():
   coverage.stop()
   coverage.report([atom.core, atom.http_core, atom.auth, atom.data,
       atom.mock_http_core, atom.client, gdata.gauth, gdata.client,
-      gdata.data])
+      gdata.data, gdata.blogger.data, gdata.blogger.client])
diff --git a/tests/atom_tests/data_test.py b/tests/atom_tests/data_test.py
@@ -722,6 +722,35 @@ def testConvertExampleXML(self):
       self.fail('Error when converting XML')
 
 
+class VersionedXmlTest(unittest.TestCase):
+
+  def test_monoversioned_parent_with_multiversioned_child(self):
+    v2_rules = atom.data.Entry._get_rules(2)
+    self.assertTrue('{http://www.w3.org/2007/app}control' in v2_rules[1])
+
+    entry_xml = """<entry xmlns='http://www.w3.org/2005/Atom'>
+                     <app:control xmlns:app='http://www.w3.org/2007/app'>
+                       <app:draft>yes</app:draft>
+                     </app:control>
+                   </entry>"""
+
+    entry = e = atom.core.parse(entry_xml, atom.data.Entry, version=2)
+    self.assertTrue(entry is not None)
+    self.assertTrue(entry.control is not None)
+    self.assertTrue(entry.control.draft is not None)
+    self.assertEqual(entry.control.draft.text, 'yes')
+
+    # v1 rules should not parse v2 XML.
+    entry = e = atom.core.parse(entry_xml, atom.data.Entry, version=1)
+    self.assertTrue(entry is not None)
+    self.assertTrue(entry.control is None)
+    
+    # The default version should be v1.
+    entry = e = atom.core.parse(entry_xml, atom.data.Entry)
+    self.assertTrue(entry is not None)
+    self.assertTrue(entry.control is None)
+
+
 def suite():
   return conf.build_suite([AuthorTest, EmailTest, NameTest, 
                            ExtensionElementTest, LinkTest, GeneratorTest,
@@ -730,7 +759,7 @@ def suite():
                            PublishedTest, FeedEntryParentTest, EntryTest,
                            ContentEntryParentTest, PreserveUnkownElementTest,
                            FeedTest, LinkFinderTest, AtomBaseTest, 
-                           UtfParsingTest])
+                           UtfParsingTest, VersionedXmlTest])
 
 
 if __name__ == '__main__':
diff --git a/tests/gdata_tests/blogger/live_client_test.py b/tests/gdata_tests/blogger/live_client_test.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2009 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# This module is used for version 2 of the Google Data APIs.
+# These tests attempt to connect to Google servers.
+
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+
+import unittest
+import gdata.blogger.client
+import gdata.blogger.data
+import gdata.gauth
+import gdata.client
+import atom.http_core
+import atom.mock_http_core
+import atom.core
+import gdata.data
+import gdata.test_config as conf
+
+
+class BloggerClientTest(unittest.TestCase):
+
+  def setUp(self):
+    self.client = None
+    if conf.settings.RUN_LIVE_TESTS:
+      self.client = gdata.blogger.client.BloggerClient()
+      conf.configure_client(self.client, conf.settings.BloggerConfig, 
+          'BloggerTest')
+
+  def tearDown(self):
+    conf.close_client(self.client)
+
+  def test_create_update_delete(self):
+    if not conf.settings.RUN_LIVE_TESTS:
+      return
+    # Either load the recording or prepare to make a live request.
+    conf.configure_cache(self.client, 'test_create_update_delete')
+
+    # Add a blog post.
+    created = self.client.add_post(conf.settings.BloggerConfig.blog_id,
+                                   conf.settings.BloggerConfig.title,
+                                   conf.settings.BloggerConfig.content,
+                                   labels=['test', 'python'])
+
+    self.assertEqual(created.title.text, conf.settings.BloggerConfig.title)
+    self.assertEqual(created.content.text, conf.settings.BloggerConfig.content)
+    self.assertEqual(len(created.category), 2)
+    self.assertTrue(created.control is None)
+
+    # Change the title of the blog post we just added.
+    created.title.text = 'Edited'
+    updated = self.client.update(created)
+
+    self.assertEqual(updated.title.text, 'Edited')
+    self.assertTrue(isinstance(updated, gdata.blogger.data.BlogPost))
+    self.assertEqual(updated.content.text, created.content.text)
+
+    # Delete the test entry from the blog.
+    self.client.delete(updated)
+
+  def test_create_draft_post(self):
+    if not conf.settings.RUN_LIVE_TESTS:
+      return
+    conf.configure_cache(self.client, 'test_create_draft_post')
+
+    # Add a draft blog post.
+    created = self.client.add_post(conf.settings.BloggerConfig.blog_id,
+                                   conf.settings.BloggerConfig.title,
+                                   conf.settings.BloggerConfig.content,
+                                   labels=['test2', 'python'], draft=True)
+
+    self.assertEqual(created.title.text, conf.settings.BloggerConfig.title)
+    self.assertEqual(created.content.text, conf.settings.BloggerConfig.content)
+    self.assertEqual(len(created.category), 2)
+    self.assertTrue(created.control is not None)
+    self.assertTrue(created.control.draft is not None)
+    self.assertEqual(created.control.draft.text, 'yes')
+    
+    # Publish the blog post. 
+    created.control.draft.text = 'no'
+    updated = self.client.update(created)
+
+    if updated.control is not None and updated.control.draft is not None:
+      self.assertNotEqual(updated.control.draft.text, 'yes')
+      
+    raw_input('pause')
+
+    # Delete the test entry from the blog.
+    self.client.delete(updated)
+
+
+def suite():
+  return conf.build_suite([BloggerClientTest])
+
+
+if __name__ == '__main__':
+  unittest.main()
diff --git a/tests/gdata_tests/client_test.py b/tests/gdata_tests/client_test.py
