| #!/usr/bin/python |
| # |
| # Copyright (C) 2007 SIOS Technology, 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. |
| |
| |
| __author__ = 'tmatsuo@sios.com (Takashi MATSUO)' |
| |
| import unittest |
| try: |
| from xml.etree import ElementTree |
| except ImportError: |
| from elementtree import ElementTree |
| import atom |
| import gdata |
| from gdata import test_data |
| import gdata.apps |
| |
| class AppsEmailListRecipientFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.rcpt_feed = gdata.apps.EmailListRecipientFeedFromString( |
| test_data.EMAIL_LIST_RECIPIENT_FEED) |
| |
| def testEmailListRecipientEntryCount(self): |
| """Count EmailListRecipient entries in EmailListRecipientFeed""" |
| |
| self.assertEquals(len(self.rcpt_feed.entry), 2) |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.rcpt_feed.GetSelfLink() is not None) |
| self.assert_(self.rcpt_feed.GetNextLink() is not None) |
| self.assert_(self.rcpt_feed.GetEditLink() is None) |
| self.assert_(self.rcpt_feed.GetHtmlLink() is None) |
| |
| def testStartItem(self): |
| """Tests the existence of <openSearch:startIndex> in |
| EmailListRecipientFeed and verifies the value""" |
| |
| self.assert_(isinstance(self.rcpt_feed.start_index, gdata.StartIndex), |
| "EmailListRecipient feed <openSearch:startIndex> element must be " + |
| "an instance of gdata.OpenSearch: %s" % self.rcpt_feed.start_index) |
| self.assertEquals(self.rcpt_feed.start_index.text, "1") |
| |
| def testEmailListRecipientEntries(self): |
| """Tests the existence of <atom:entry> in EmailListRecipientFeed |
| and simply verifies the value""" |
| |
| for a_entry in self.rcpt_feed.entry: |
| self.assert_(isinstance(a_entry, gdata.apps.EmailListRecipientEntry), |
| "EmailListRecipient Feed <atom:entry> must be an instance of " + |
| "apps.EmailListRecipientEntry: %s" % a_entry) |
| |
| self.assertEquals(self.rcpt_feed.entry[0].who.email, "joe@example.com") |
| self.assertEquals(self.rcpt_feed.entry[1].who.email, "susan@example.com") |
| |
| class AppsEmailListFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.list_feed = gdata.apps.EmailListFeedFromString( |
| test_data.EMAIL_LIST_FEED) |
| |
| def testEmailListEntryCount(self): |
| """Count EmailList entries in EmailListFeed""" |
| |
| self.assertEquals(len(self.list_feed.entry), 2) |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.list_feed.GetSelfLink() is not None) |
| self.assert_(self.list_feed.GetNextLink() is not None) |
| self.assert_(self.list_feed.GetEditLink() is None) |
| self.assert_(self.list_feed.GetHtmlLink() is None) |
| |
| def testStartItem(self): |
| """Tests the existence of <openSearch:startIndex> in EmailListFeed |
| and verifies the value""" |
| |
| self.assert_(isinstance(self.list_feed.start_index, gdata.StartIndex), |
| "EmailList feed <openSearch:startIndex> element must be an instance " + |
| "of gdata.OpenSearch: %s" % self.list_feed.start_index) |
| self.assertEquals(self.list_feed.start_index.text, "1") |
| |
| def testUserEntries(self): |
| """Tests the existence of <atom:entry> in EmailListFeed and simply |
| verifies the value""" |
| |
| for a_entry in self.list_feed.entry: |
| self.assert_(isinstance(a_entry, gdata.apps.EmailListEntry), |
| "EmailList Feed <atom:entry> must be an instance of " + |
| "apps.EmailListEntry: %s" % a_entry) |
| |
| self.assertEquals(self.list_feed.entry[0].email_list.name, "us-sales") |
| self.assertEquals(self.list_feed.entry[1].email_list.name, "us-eng") |
| |
| class AppsUserFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.user_feed = gdata.apps.UserFeedFromString(test_data.USER_FEED) |
| |
| def testUserEntryCount(self): |
| """Count User entries in UserFeed""" |
| |
| self.assertEquals(len(self.user_feed.entry), 2) |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.user_feed.GetSelfLink() is not None) |
| self.assert_(self.user_feed.GetNextLink() is not None) |
| self.assert_(self.user_feed.GetEditLink() is None) |
| self.assert_(self.user_feed.GetHtmlLink() is None) |
| |
| def testStartItem(self): |
| """Tests the existence of <openSearch:startIndex> in UserFeed and |
| verifies the value""" |
| |
| self.assert_(isinstance(self.user_feed.start_index, gdata.StartIndex), |
| "User feed <openSearch:startIndex> element must be an instance " + |
| "of gdata.OpenSearch: %s" % self.user_feed.start_index) |
| self.assertEquals(self.user_feed.start_index.text, "1") |
| |
| def testUserEntries(self): |
| """Tests the existence of <atom:entry> in UserFeed and simply |
| verifies the value""" |
| |
| for a_entry in self.user_feed.entry: |
| self.assert_(isinstance(a_entry, gdata.apps.UserEntry), |
| "User Feed <atom:entry> must be an instance of " + |
| "apps.UserEntry: %s" % a_entry) |
| |
| self.assertEquals(self.user_feed.entry[0].login.user_name, "TestUser") |
| self.assertEquals(self.user_feed.entry[0].who.email, |
| "TestUser@example.com") |
| self.assertEquals(self.user_feed.entry[1].login.user_name, "JohnSmith") |
| self.assertEquals(self.user_feed.entry[1].who.email, |
| "JohnSmith@example.com") |
| |
| class AppsNicknameFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.nick_feed = gdata.apps.NicknameFeedFromString(test_data.NICK_FEED) |
| |
| def testNicknameEntryCount(self): |
| """Count Nickname entries in NicknameFeed""" |
| |
| self.assertEquals(len(self.nick_feed.entry), 2) |
| |
| def testId(self): |
| """Tests the existence of <atom:id> in NicknameFeed and verifies |
| the value""" |
| |
| self.assert_(isinstance(self.nick_feed.id, atom.Id), |
| "Nickname feed <atom:id> element must be an instance of " + |
| "atom.Id: %s" % self.nick_feed.id) |
| |
| self.assertEquals(self.nick_feed.id.text, |
| "http://apps-apis.google.com/a/feeds/example.com/nickname/2.0") |
| |
| def testStartItem(self): |
| """Tests the existence of <openSearch:startIndex> in NicknameFeed |
| and verifies the value""" |
| |
| self.assert_(isinstance(self.nick_feed.start_index, gdata.StartIndex), |
| "Nickname feed <openSearch:startIndex> element must be an instance " + |
| "of gdata.OpenSearch: %s" % self.nick_feed.start_index) |
| self.assertEquals(self.nick_feed.start_index.text, "1") |
| |
| def testItemsPerPage(self): |
| """Tests the existence of <openSearch:itemsPerPage> in |
| NicknameFeed and verifies the value""" |
| |
| self.assert_(isinstance(self.nick_feed.items_per_page, gdata.ItemsPerPage), |
| "Nickname feed <openSearch:itemsPerPage> element must be an " + |
| "instance of gdata.ItemsPerPage: %s" % self.nick_feed.items_per_page) |
| |
| self.assertEquals(self.nick_feed.items_per_page.text, "2") |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.nick_feed.GetSelfLink() is not None) |
| self.assert_(self.nick_feed.GetEditLink() is None) |
| self.assert_(self.nick_feed.GetHtmlLink() is None) |
| |
| def testNicknameEntries(self): |
| """Tests the existence of <atom:entry> in NicknameFeed and simply |
| verifies the value""" |
| |
| for a_entry in self.nick_feed.entry: |
| self.assert_(isinstance(a_entry, gdata.apps.NicknameEntry), |
| "Nickname Feed <atom:entry> must be an instance of " + |
| "apps.NicknameEntry: %s" % a_entry) |
| |
| self.assertEquals(self.nick_feed.entry[0].nickname.name, "Foo") |
| self.assertEquals(self.nick_feed.entry[1].nickname.name, "Bar") |
| |
| class AppsEmailListRecipientEntryTest(unittest.TestCase): |
| |
| def setUp(self): |
| |
| self.rcpt_entry = gdata.apps.EmailListRecipientEntryFromString( |
| test_data.EMAIL_LIST_RECIPIENT_ENTRY) |
| |
| def testId(self): |
| """Tests the existence of <atom:id> in EmailListRecipientEntry and |
| verifies the value""" |
| |
| self.assert_( |
| isinstance(self.rcpt_entry.id, atom.Id), |
| "EmailListRecipient entry <atom:id> element must be an instance of " + |
| "atom.Id: %s" % |
| self.rcpt_entry.id) |
| |
| self.assertEquals( |
| self.rcpt_entry.id.text, |
| 'https://apps-apis.google.com/a/feeds/example.com/emailList/2.0/us-sales/' + |
| 'recipient/TestUser%40example.com') |
| |
| def testUpdated(self): |
| """Tests the existence of <atom:updated> in |
| EmailListRecipientEntry and verifies the value""" |
| |
| self.assert_( |
| isinstance(self.rcpt_entry.updated, atom.Updated), |
| "EmailListRecipient entry <atom:updated> element must be an instance " + |
| "of atom.Updated: %s" % self.rcpt_entry.updated) |
| |
| self.assertEquals(self.rcpt_entry.updated.text, |
| '1970-01-01T00:00:00.000Z') |
| |
| def testCategory(self): |
| """Tests the existence of <atom:category> in |
| EmailListRecipientEntry and verifies the value""" |
| |
| for a_category in self.rcpt_entry.category: |
| self.assert_( |
| isinstance(a_category, atom.Category), |
| "EmailListRecipient entry <atom:category> element must be an " + |
| "instance of atom.Category: %s" % a_category) |
| |
| self.assertEquals(a_category.scheme, |
| "http://schemas.google.com/g/2005#kind") |
| |
| self.assertEquals(a_category.term, |
| "http://schemas.google.com/apps/2006#" + |
| "emailList.recipient") |
| |
| def testTitle(self): |
| """Tests the existence of <atom:title> in EmailListRecipientEntry |
| and verifies the value""" |
| |
| self.assert_( |
| isinstance(self.rcpt_entry.title, atom.Title), |
| "EmailListRecipient entry <atom:title> element must be an instance of " + |
| "atom.Title: %s" % self.rcpt_entry.title) |
| |
| self.assertEquals(self.rcpt_entry.title.text, 'TestUser') |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.rcpt_entry.GetSelfLink() is not None) |
| self.assert_(self.rcpt_entry.GetEditLink() is not None) |
| self.assert_(self.rcpt_entry.GetHtmlLink() is None) |
| |
| def testWho(self): |
| """Tests the existence of a <gdata:who> in EmailListRecipientEntry |
| and verifies the value""" |
| |
| self.assert_(isinstance(self.rcpt_entry.who, gdata.apps.Who), |
| "EmailListRecipient entry <gdata:who> must be an instance of " + |
| "apps.Who: %s" % self.rcpt_entry.who) |
| self.assertEquals(self.rcpt_entry.who.email, 'TestUser@example.com') |
| |
| class AppsEmailListEntryTest(unittest.TestCase): |
| |
| def setUp(self): |
| |
| self.list_entry = gdata.apps.EmailListEntryFromString( |
| test_data.EMAIL_LIST_ENTRY) |
| |
| def testId(self): |
| """Tests the existence of <atom:id> in EmailListEntry and verifies |
| the value""" |
| |
| self.assert_( |
| isinstance(self.list_entry.id, atom.Id), |
| "EmailList entry <atom:id> element must be an instance of atom.Id: %s" % |
| self.list_entry.id) |
| |
| self.assertEquals( |
| self.list_entry.id.text, |
| 'https://apps-apis.google.com/a/feeds/example.com/emailList/2.0/testlist') |
| |
| def testUpdated(self): |
| """Tests the existence of <atom:updated> in EmailListEntry and |
| verifies the value""" |
| |
| self.assert_( |
| isinstance(self.list_entry.updated, atom.Updated), |
| "EmailList entry <atom:updated> element must be an instance of " + |
| "atom.Updated: %s" % self.list_entry.updated) |
| |
| self.assertEquals(self.list_entry.updated.text, |
| '1970-01-01T00:00:00.000Z') |
| |
| def testCategory(self): |
| """Tests the existence of <atom:category> in EmailListEntry and |
| verifies the value""" |
| |
| for a_category in self.list_entry.category: |
| self.assert_( |
| isinstance(a_category, atom.Category), |
| "EmailList entry <atom:category> element must be an instance " + |
| "of atom.Category: %s" % a_category) |
| |
| self.assertEquals(a_category.scheme, |
| "http://schemas.google.com/g/2005#kind") |
| |
| self.assertEquals(a_category.term, |
| "http://schemas.google.com/apps/2006#emailList") |
| |
| def testTitle(self): |
| """Tests the existence of <atom:title> in EmailListEntry and verifies |
| the value""" |
| |
| self.assert_( |
| isinstance(self.list_entry.title, atom.Title), |
| "EmailList entry <atom:title> element must be an instance of " + |
| "atom.Title: %s" % self.list_entry.title) |
| |
| self.assertEquals(self.list_entry.title.text, 'testlist') |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.list_entry.GetSelfLink() is not None) |
| self.assert_(self.list_entry.GetEditLink() is not None) |
| self.assert_(self.list_entry.GetHtmlLink() is None) |
| |
| def testEmailList(self): |
| """Tests the existence of a <apps:emailList> in EmailListEntry and |
| verifies the value""" |
| |
| self.assert_(isinstance(self.list_entry.email_list, gdata.apps.EmailList), |
| "EmailList entry <apps:emailList> must be an instance of " + |
| "apps.EmailList: %s" % self.list_entry.email_list) |
| self.assertEquals(self.list_entry.email_list.name, 'testlist') |
| |
| def testFeedLink(self): |
| """Test the existence of a <gdata:feedLink> in EmailListEntry and |
| verifies the value""" |
| |
| for an_feed_link in self.list_entry.feed_link: |
| self.assert_(isinstance(an_feed_link, gdata.FeedLink), |
| "EmailList entry <gdata:feedLink> must be an instance of " + |
| "gdata.FeedLink: %s" % an_feed_link) |
| self.assertEquals(self.list_entry.feed_link[0].rel, |
| 'http://schemas.google.com/apps/2006#' + |
| 'emailList.recipients') |
| self.assertEquals(self.list_entry.feed_link[0].href, |
| 'http://apps-apis.google.com/a/feeds/example.com/emailList/' + |
| '2.0/testlist/recipient/') |
| |
| class AppsNicknameEntryTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.nick_entry = gdata.apps.NicknameEntryFromString(test_data.NICK_ENTRY) |
| |
| def testId(self): |
| """Tests the existence of <atom:id> in NicknameEntry and verifies |
| the value""" |
| |
| self.assert_( |
| isinstance(self.nick_entry.id, atom.Id), |
| "Nickname entry <atom:id> element must be an instance of atom.Id: %s" % |
| self.nick_entry.id) |
| |
| self.assertEquals( |
| self.nick_entry.id.text, |
| 'https://apps-apis.google.com/a/feeds/example.com/nickname/2.0/Foo') |
| |
| def testCategory(self): |
| """Tests the existence of <atom:category> in NicknameEntry and |
| verifies the value""" |
| |
| for a_category in self.nick_entry.category: |
| self.assert_( |
| isinstance(a_category, atom.Category), |
| "Nickname entry <atom:category> element must be an instance " + |
| "of atom.Category: %s" % a_category) |
| |
| self.assertEquals(a_category.scheme, |
| "http://schemas.google.com/g/2005#kind") |
| |
| self.assertEquals(a_category.term, |
| "http://schemas.google.com/apps/2006#nickname") |
| |
| def testTitle(self): |
| """Tests the existence of <atom:title> in NicknameEntry and |
| verifies the value""" |
| |
| self.assert_(isinstance(self.nick_entry.title, atom.Title), |
| "Nickname entry <atom:title> element must be an instance " + |
| "of atom.Title: %s" % self.nick_entry.title) |
| |
| self.assertEquals(self.nick_entry.title.text, "Foo") |
| |
| def testLogin(self): |
| """Tests the existence of <apps:login> in NicknameEntry and |
| verifies the value""" |
| |
| self.assert_(isinstance(self.nick_entry.login, gdata.apps.Login), |
| "Nickname entry <apps:login> element must be an instance " + |
| "of apps.Login: %s" % self.nick_entry.login) |
| self.assertEquals(self.nick_entry.login.user_name, "TestUser") |
| |
| def testNickname(self): |
| """Tests the existence of <apps:nickname> in NicknameEntry and |
| verifies the value""" |
| |
| self.assert_(isinstance(self.nick_entry.nickname, gdata.apps.Nickname), |
| "Nickname entry <apps:nickname> element must be an instance " + |
| "of apps.Nickname: %s" % self.nick_entry.nickname) |
| self.assertEquals(self.nick_entry.nickname.name, "Foo") |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.nick_entry.GetSelfLink() is not None) |
| self.assert_(self.nick_entry.GetEditLink() is not None) |
| self.assert_(self.nick_entry.GetHtmlLink() is None) |
| |
| class AppsUserEntryTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.user_entry = gdata.apps.UserEntryFromString(test_data.USER_ENTRY) |
| |
| def testId(self): |
| """Tests the existence of <atom:id> in UserEntry and verifies the |
| value""" |
| |
| self.assert_( |
| isinstance(self.user_entry.id, atom.Id), |
| "User entry <atom:id> element must be an instance of atom.Id: %s" % |
| self.user_entry.id) |
| |
| self.assertEquals( |
| self.user_entry.id.text, |
| 'https://apps-apis.google.com/a/feeds/example.com/user/2.0/TestUser') |
| |
| def testUpdated(self): |
| """Tests the existence of <atom:updated> in UserEntry and verifies |
| the value""" |
| |
| self.assert_( |
| isinstance(self.user_entry.updated, atom.Updated), |
| "User entry <atom:updated> element must be an instance of " + |
| "atom.Updated: %s" % self.user_entry.updated) |
| |
| self.assertEquals(self.user_entry.updated.text, |
| '1970-01-01T00:00:00.000Z') |
| |
| def testCategory(self): |
| """Tests the existence of <atom:category> in UserEntry and |
| verifies the value""" |
| |
| for a_category in self.user_entry.category: |
| self.assert_( |
| isinstance(a_category, atom.Category), |
| "User entry <atom:category> element must be an instance " + |
| "of atom.Category: %s" % a_category) |
| |
| self.assertEquals(a_category.scheme, |
| "http://schemas.google.com/g/2005#kind") |
| |
| self.assertEquals(a_category.term, |
| "http://schemas.google.com/apps/2006#user") |
| |
| def testTitle(self): |
| """Tests the existence of <atom:title> in UserEntry and verifies |
| the value""" |
| |
| self.assert_( |
| isinstance(self.user_entry.title, atom.Title), |
| "User entry <atom:title> element must be an instance of atom.Title: %s" % |
| self.user_entry.title) |
| |
| self.assertEquals(self.user_entry.title.text, 'TestUser') |
| |
| def testLinkFinderFindsHtmlLink(self): |
| """Tests the return value of GetXXXLink() methods""" |
| |
| self.assert_(self.user_entry.GetSelfLink() is not None) |
| self.assert_(self.user_entry.GetEditLink() is not None) |
| self.assert_(self.user_entry.GetHtmlLink() is None) |
| |
| def testLogin(self): |
| """Tests the existence of <apps:login> in UserEntry and verifies |
| the value""" |
| |
| self.assert_(isinstance(self.user_entry.login, gdata.apps.Login), |
| "User entry <apps:login> element must be an instance of apps.Login: %s" |
| % self.user_entry.login) |
| |
| self.assertEquals(self.user_entry.login.user_name, 'TestUser') |
| self.assertEquals(self.user_entry.login.password, 'password') |
| self.assertEquals(self.user_entry.login.suspended, 'false') |
| self.assertEquals(self.user_entry.login.ip_whitelisted, 'false') |
| self.assertEquals(self.user_entry.login.hash_function_name, 'SHA-1') |
| |
| def testName(self): |
| """Tests the existence of <apps:name> in UserEntry and verifies |
| the value""" |
| |
| self.assert_(isinstance(self.user_entry.name, gdata.apps.Name), |
| "User entry <apps:name> element must be an instance of apps.Name: %s" |
| % self.user_entry.name) |
| self.assertEquals(self.user_entry.name.family_name, 'Test') |
| self.assertEquals(self.user_entry.name.given_name, 'User') |
| |
| def testQuota(self): |
| """Tests the existence of <apps:quota> in UserEntry and verifies |
| the value""" |
| |
| self.assert_(isinstance(self.user_entry.quota, gdata.apps.Quota), |
| "User entry <apps:quota> element must be an instance of apps.Quota: %s" |
| % self.user_entry.quota) |
| self.assertEquals(self.user_entry.quota.limit, '1024') |
| |
| def testFeedLink(self): |
| """Test the existence of a <gdata:feedLink> in UserEntry and |
| verifies the value""" |
| |
| for an_feed_link in self.user_entry.feed_link: |
| self.assert_(isinstance(an_feed_link, gdata.FeedLink), |
| "User entry <gdata:feedLink> must be an instance of gdata.FeedLink" + |
| ": %s" % an_feed_link) |
| self.assertEquals(self.user_entry.feed_link[0].rel, |
| 'http://schemas.google.com/apps/2006#user.nicknames') |
| self.assertEquals(self.user_entry.feed_link[0].href, |
| 'https://apps-apis.google.com/a/feeds/example.com/nickname/' + |
| '2.0?username=Test-3121') |
| self.assertEquals(self.user_entry.feed_link[1].rel, |
| 'http://schemas.google.com/apps/2006#user.emailLists') |
| self.assertEquals(self.user_entry.feed_link[1].href, |
| 'https://apps-apis.google.com/a/feeds/example.com/emailList/' + |
| '2.0?recipient=testlist@example.com') |
| |
| def testUpdate(self): |
| """Tests for modifing attributes of UserEntry""" |
| |
| self.user_entry.name.family_name = 'ModifiedFamilyName' |
| self.user_entry.name.given_name = 'ModifiedGivenName' |
| self.user_entry.quota.limit = '2048' |
| self.user_entry.login.password = 'ModifiedPassword' |
| self.user_entry.login.suspended = 'true' |
| modified = gdata.apps.UserEntryFromString(self.user_entry.ToString()) |
| |
| self.assertEquals(modified.name.family_name, 'ModifiedFamilyName') |
| self.assertEquals(modified.name.given_name, 'ModifiedGivenName') |
| self.assertEquals(modified.quota.limit, '2048') |
| self.assertEquals(modified.login.password, 'ModifiedPassword') |
| self.assertEquals(modified.login.suspended, 'true') |
| |
| if __name__ == '__main__': |
| unittest.main() |
| |
