| #!/usr/bin/python |
| # |
| # Copyright (C) 2008 Yu-Jie Lin |
| # |
| # 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__ = 'livibetter (Yu-Jie Lin)' |
| |
| |
| import unittest |
| try: |
| from xml.etree import ElementTree |
| except ImportError: |
| from elementtree import ElementTree |
| import gdata |
| from gdata import test_data |
| import gdata.webmastertools as webmastertools |
| |
| |
| class IndexedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.indexed = webmastertools.Indexed() |
| |
| def testToAndFromString(self): |
| self.indexed.text = 'true' |
| self.assert_(self.indexed.text == 'true') |
| new_indexed = webmastertools.IndexedFromString(self.indexed.ToString()) |
| self.assert_(self.indexed.text == new_indexed.text) |
| |
| |
| class CrawledTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.crawled = webmastertools.Crawled() |
| |
| def testToAndFromString(self): |
| self.crawled.text = 'true' |
| self.assert_(self.crawled.text == 'true') |
| new_crawled = webmastertools.CrawledFromString(self.crawled.ToString()) |
| self.assert_(self.crawled.text == new_crawled.text) |
| |
| |
| class GeoLocationTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.geolocation = webmastertools.GeoLocation() |
| |
| def testToAndFromString(self): |
| self.geolocation.text = 'US' |
| self.assert_(self.geolocation.text == 'US') |
| new_geolocation = webmastertools.GeoLocationFromString( |
| self.geolocation.ToString()) |
| self.assert_(self.geolocation.text == new_geolocation.text) |
| |
| |
| class PreferredDomainTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.preferred_domain = webmastertools.PreferredDomain() |
| |
| def testToAndFromString(self): |
| self.preferred_domain.text = 'none' |
| self.assert_(self.preferred_domain.text == 'none') |
| new_preferred_domain = webmastertools.PreferredDomainFromString( |
| self.preferred_domain.ToString()) |
| self.assert_(self.preferred_domain.text == new_preferred_domain.text) |
| |
| |
| class CrawlRateTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.crawl_rate = webmastertools.CrawlRate() |
| |
| def testToAndFromString(self): |
| self.crawl_rate.text = 'normal' |
| self.assert_(self.crawl_rate.text == 'normal') |
| new_crawl_rate = webmastertools.CrawlRateFromString( |
| self.crawl_rate.ToString()) |
| self.assert_(self.crawl_rate.text == new_crawl_rate.text) |
| |
| |
| class EnhancedImageSearchTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.enhanced_image_search = webmastertools.EnhancedImageSearch() |
| |
| def testToAndFromString(self): |
| self.enhanced_image_search.text = 'true' |
| self.assert_(self.enhanced_image_search.text == 'true') |
| new_enhanced_image_search = webmastertools.EnhancedImageSearchFromString( |
| self.enhanced_image_search.ToString()) |
| self.assert_(self.enhanced_image_search.text == |
| new_enhanced_image_search.text) |
| |
| |
| class VerifiedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.verified = webmastertools.Verified() |
| |
| def testToAndFromString(self): |
| self.verified.text = 'true' |
| self.assert_(self.verified.text == 'true') |
| new_verified = webmastertools.VerifiedFromString(self.verified.ToString()) |
| self.assert_(self.verified.text == new_verified.text) |
| |
| |
| class VerificationMethodMetaTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.meta = webmastertools.VerificationMethodMeta() |
| |
| def testToAndFromString(self): |
| self.meta.name = 'verify-vf1' |
| self.meta.content = 'a2Ai' |
| self.assert_(self.meta.name == 'verify-vf1') |
| self.assert_(self.meta.content == 'a2Ai') |
| new_meta = webmastertools.VerificationMethodMetaFromString( |
| self.meta.ToString()) |
| self.assert_(self.meta.name == new_meta.name) |
| self.assert_(self.meta.content == new_meta.content) |
| |
| |
| class VerificationMethodTest(unittest.TestCase): |
| |
| def setUp(self): |
| pass |
| |
| def testMetaTagToAndFromString(self): |
| self.method = webmastertools.VerificationMethod() |
| self.method.type = 'metatag' |
| self.method.in_use = 'false' |
| self.assert_(self.method.type == 'metatag') |
| self.assert_(self.method.in_use == 'false') |
| self.method.meta = webmastertools.VerificationMethodMeta(name='verify-vf1', |
| content='a2Ai') |
| self.assert_(self.method.meta.name == 'verify-vf1') |
| self.assert_(self.method.meta.content == 'a2Ai') |
| new_method = webmastertools.VerificationMethodFromString( |
| self.method.ToString()) |
| self.assert_(self.method.type == new_method.type) |
| self.assert_(self.method.in_use == new_method.in_use) |
| self.assert_(self.method.meta.name == new_method.meta.name) |
| self.assert_(self.method.meta.content == new_method.meta.content) |
| |
| method = webmastertools.VerificationMethod(type='xyz') |
| self.assertEqual(method.type, 'xyz') |
| method = webmastertools.VerificationMethod() |
| self.assert_(method.type is None) |
| |
| def testHtmlPageToAndFromString(self): |
| self.method = webmastertools.VerificationMethod() |
| self.method.type = 'htmlpage' |
| self.method.in_use = 'false' |
| self.method.text = '456456-google.html' |
| self.assert_(self.method.type == 'htmlpage') |
| self.assert_(self.method.in_use == 'false') |
| self.assert_(self.method.text == '456456-google.html') |
| self.assert_(self.method.meta is None) |
| new_method = webmastertools.VerificationMethodFromString( |
| self.method.ToString()) |
| self.assert_(self.method.type == new_method.type) |
| self.assert_(self.method.in_use == new_method.in_use) |
| self.assert_(self.method.text == new_method.text) |
| self.assert_(self.method.meta is None) |
| |
| def testConvertActualData(self): |
| feed = webmastertools.SitesFeedFromString(test_data.SITES_FEED) |
| self.assert_(len(feed.entry[0].verification_method) == 2) |
| check = 0 |
| for method in feed.entry[0].verification_method: |
| self.assert_(isinstance(method, webmastertools.VerificationMethod)) |
| if method.type == 'metatag': |
| self.assert_(method.in_use == 'false') |
| self.assert_(method.text is None) |
| self.assert_(method.meta.name == 'verify-v1') |
| self.assert_(method.meta.content == 'a2Ai') |
| check = check | 1 |
| elif method.type == 'htmlpage': |
| self.assert_(method.in_use == 'false') |
| self.assert_(method.text == '456456-google.html') |
| check = check | 2 |
| else: |
| self.fail('Wrong Verification Method: %s' % method.type) |
| self.assert_(check == 2 ** 2 - 1, |
| 'Should only have two Verification Methods, metatag and htmlpage') |
| |
| |
| class MarkupLanguageTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.markup_language = webmastertools.MarkupLanguage() |
| |
| def testToAndFromString(self): |
| self.markup_language.text = 'HTML' |
| self.assert_(self.markup_language.text == 'HTML') |
| new_markup_language = webmastertools.MarkupLanguageFromString( |
| self.markup_language.ToString()) |
| self.assert_(self.markup_language.text == new_markup_language.text) |
| |
| |
| class SitemapMobileTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_mobile = webmastertools.SitemapMobile() |
| |
| def testToAndFromString(self): |
| self.sitemap_mobile.markup_language.append(webmastertools.MarkupLanguage( |
| text = 'HTML')) |
| self.assert_(self.sitemap_mobile.text is None) |
| self.assert_(self.sitemap_mobile.markup_language[0].text == 'HTML') |
| new_sitemap_mobile = webmastertools.SitemapMobileFromString( |
| self.sitemap_mobile.ToString()) |
| self.assert_(new_sitemap_mobile.text is None) |
| self.assert_(self.sitemap_mobile.markup_language[0].text == |
| new_sitemap_mobile.markup_language[0].text) |
| |
| def testConvertActualData(self): |
| feed = webmastertools.SitemapsFeedFromString(test_data.SITEMAPS_FEED) |
| self.assert_(feed.sitemap_mobile.text.strip() == '') |
| self.assert_(len(feed.sitemap_mobile.markup_language) == 2) |
| check = 0 |
| for markup_language in feed.sitemap_mobile.markup_language: |
| self.assert_(isinstance(markup_language, webmastertools.MarkupLanguage)) |
| if markup_language.text == "HTML": |
| check = check | 1 |
| elif markup_language.text == "WAP": |
| check = check | 2 |
| else: |
| self.fail('Unexpected markup language: %s' % markup_language.text) |
| self.assert_(check == 2 ** 2 - 1, "Something is wrong with markup language") |
| |
| |
| class SitemapMobileMarkupLanguageTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_mobile_markup_language =\ |
| webmastertools.SitemapMobileMarkupLanguage() |
| |
| def testToAndFromString(self): |
| self.sitemap_mobile_markup_language.text = 'HTML' |
| self.assert_(self.sitemap_mobile_markup_language.text == 'HTML') |
| new_sitemap_mobile_markup_language =\ |
| webmastertools.SitemapMobileMarkupLanguageFromString( |
| self.sitemap_mobile_markup_language.ToString()) |
| self.assert_(self.sitemap_mobile_markup_language.text ==\ |
| new_sitemap_mobile_markup_language.text) |
| |
| |
| class PublicationLabelTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.publication_label = webmastertools.PublicationLabel() |
| |
| def testToAndFromString(self): |
| self.publication_label.text = 'Value1' |
| self.assert_(self.publication_label.text == 'Value1') |
| new_publication_label = webmastertools.PublicationLabelFromString( |
| self.publication_label.ToString()) |
| self.assert_(self.publication_label.text == new_publication_label.text) |
| |
| |
| class SitemapNewsTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_news = webmastertools.SitemapNews() |
| |
| def testToAndFromString(self): |
| self.sitemap_news.publication_label.append(webmastertools.PublicationLabel( |
| text = 'Value1')) |
| self.assert_(self.sitemap_news.text is None) |
| self.assert_(self.sitemap_news.publication_label[0].text == 'Value1') |
| new_sitemap_news = webmastertools.SitemapNewsFromString( |
| self.sitemap_news.ToString()) |
| self.assert_(new_sitemap_news.text is None) |
| self.assert_(self.sitemap_news.publication_label[0].text == |
| new_sitemap_news.publication_label[0].text) |
| |
| def testConvertActualData(self): |
| feed = webmastertools.SitemapsFeedFromString(test_data.SITEMAPS_FEED) |
| self.assert_(len(feed.sitemap_news.publication_label) == 3) |
| check = 0 |
| for publication_label in feed.sitemap_news.publication_label: |
| if publication_label.text == "Value1": |
| check = check | 1 |
| elif publication_label.text == "Value2": |
| check = check | 2 |
| elif publication_label.text == "Value3": |
| check = check | 4 |
| else: |
| self.fail('Unexpected publication label: %s' % markup_language.text) |
| self.assert_(check == 2 ** 3 - 1, |
| 'Something is wrong with publication label') |
| |
| |
| class SitemapNewsPublicationLabelTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_news_publication_label =\ |
| webmastertools.SitemapNewsPublicationLabel() |
| |
| def testToAndFromString(self): |
| self.sitemap_news_publication_label.text = 'LabelValue' |
| self.assert_(self.sitemap_news_publication_label.text == 'LabelValue') |
| new_sitemap_news_publication_label =\ |
| webmastertools.SitemapNewsPublicationLabelFromString( |
| self.sitemap_news_publication_label.ToString()) |
| self.assert_(self.sitemap_news_publication_label.text ==\ |
| new_sitemap_news_publication_label.text) |
| |
| |
| class SitemapLastDownloadedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_last_downloaded = webmastertools.SitemapLastDownloaded() |
| |
| def testToAndFromString(self): |
| self.sitemap_last_downloaded.text = '2006-11-18T19:27:32.543Z' |
| self.assert_(self.sitemap_last_downloaded.text ==\ |
| '2006-11-18T19:27:32.543Z') |
| new_sitemap_last_downloaded =\ |
| webmastertools.SitemapLastDownloadedFromString( |
| self.sitemap_last_downloaded.ToString()) |
| self.assert_(self.sitemap_last_downloaded.text ==\ |
| new_sitemap_last_downloaded.text) |
| |
| |
| class SitemapTypeTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_type = webmastertools.SitemapType() |
| |
| def testToAndFromString(self): |
| self.sitemap_type.text = 'WEB' |
| self.assert_(self.sitemap_type.text == 'WEB') |
| new_sitemap_type = webmastertools.SitemapTypeFromString( |
| self.sitemap_type.ToString()) |
| self.assert_(self.sitemap_type.text == new_sitemap_type.text) |
| |
| |
| class SitemapStatusTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_status = webmastertools.SitemapStatus() |
| |
| def testToAndFromString(self): |
| self.sitemap_status.text = 'Pending' |
| self.assert_(self.sitemap_status.text == 'Pending') |
| new_sitemap_status = webmastertools.SitemapStatusFromString( |
| self.sitemap_status.ToString()) |
| self.assert_(self.sitemap_status.text == new_sitemap_status.text) |
| |
| |
| class SitemapUrlCountTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.sitemap_url_count = webmastertools.SitemapUrlCount() |
| |
| def testToAndFromString(self): |
| self.sitemap_url_count.text = '0' |
| self.assert_(self.sitemap_url_count.text == '0') |
| new_sitemap_url_count = webmastertools.SitemapUrlCountFromString( |
| self.sitemap_url_count.ToString()) |
| self.assert_(self.sitemap_url_count.text == new_sitemap_url_count.text) |
| |
| |
| class SitesEntryTest(unittest.TestCase): |
| |
| def setUp(self): |
| pass |
| |
| def testToAndFromString(self): |
| entry = webmastertools.SitesEntry( |
| indexed=webmastertools.Indexed(text='true'), |
| crawled=webmastertools.Crawled(text='2008-09-14T08:59:28.000'), |
| geolocation=webmastertools.GeoLocation(text='US'), |
| preferred_domain=webmastertools.PreferredDomain(text='none'), |
| crawl_rate=webmastertools.CrawlRate(text='normal'), |
| enhanced_image_search=webmastertools.EnhancedImageSearch(text='true'), |
| verified=webmastertools.Verified(text='false'), |
| ) |
| self.assert_(entry.indexed.text == 'true') |
| self.assert_(entry.crawled.text == '2008-09-14T08:59:28.000') |
| self.assert_(entry.geolocation.text == 'US') |
| self.assert_(entry.preferred_domain.text == 'none') |
| self.assert_(entry.crawl_rate.text == 'normal') |
| self.assert_(entry.enhanced_image_search.text == 'true') |
| self.assert_(entry.verified.text == 'false') |
| new_entry = webmastertools.SitesEntryFromString(entry.ToString()) |
| self.assert_(new_entry.indexed.text == 'true') |
| self.assert_(new_entry.crawled.text == '2008-09-14T08:59:28.000') |
| self.assert_(new_entry.geolocation.text == 'US') |
| self.assert_(new_entry.preferred_domain.text == 'none') |
| self.assert_(new_entry.crawl_rate.text == 'normal') |
| self.assert_(new_entry.enhanced_image_search.text == 'true') |
| self.assert_(new_entry.verified.text == 'false') |
| |
| def testConvertActualData(self): |
| feed = webmastertools.SitesFeedFromString(test_data.SITES_FEED) |
| self.assert_(len(feed.entry) == 1) |
| entry = feed.entry[0] |
| self.assert_(isinstance(entry, webmastertools.SitesEntry)) |
| self.assert_(entry.indexed.text == 'true') |
| self.assert_(entry.crawled.text == '2008-09-14T08:59:28.000') |
| self.assert_(entry.geolocation.text == 'US') |
| self.assert_(entry.preferred_domain.text == 'none') |
| self.assert_(entry.crawl_rate.text == 'normal') |
| self.assert_(entry.enhanced_image_search.text == 'true') |
| self.assert_(entry.verified.text == 'false') |
| |
| |
| class SitesFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.feed = gdata.webmastertools.SitesFeedFromString(test_data.SITES_FEED) |
| |
| def testToAndFromString(self): |
| self.assert_(len(self.feed.entry) == 1) |
| for entry in self.feed.entry: |
| self.assert_(isinstance(entry, webmastertools.SitesEntry)) |
| new_feed = webmastertools.SitesFeedFromString(self.feed.ToString()) |
| self.assert_(len(new_feed.entry) == 1) |
| for entry in new_feed.entry: |
| self.assert_(isinstance(entry, webmastertools.SitesEntry)) |
| |
| |
| class SitemapsEntryTest(unittest.TestCase): |
| |
| def testRegularToAndFromString(self): |
| entry = webmastertools.SitemapsEntry( |
| sitemap_type=webmastertools.SitemapType(text='WEB'), |
| sitemap_status=webmastertools.SitemapStatus(text='Pending'), |
| sitemap_last_downloaded=webmastertools.SitemapLastDownloaded( |
| text='2006-11-18T19:27:32.543Z'), |
| sitemap_url_count=webmastertools.SitemapUrlCount(text='102'), |
| ) |
| self.assert_(entry.sitemap_type.text == 'WEB') |
| self.assert_(entry.sitemap_status.text == 'Pending') |
| self.assert_(entry.sitemap_last_downloaded.text ==\ |
| '2006-11-18T19:27:32.543Z') |
| self.assert_(entry.sitemap_url_count.text == '102') |
| new_entry = webmastertools.SitemapsEntryFromString(entry.ToString()) |
| self.assert_(new_entry.sitemap_type.text == 'WEB') |
| self.assert_(new_entry.sitemap_status.text == 'Pending') |
| self.assert_(new_entry.sitemap_last_downloaded.text ==\ |
| '2006-11-18T19:27:32.543Z') |
| self.assert_(new_entry.sitemap_url_count.text == '102') |
| |
| def testConvertActualData(self): |
| feed = gdata.webmastertools.SitemapsFeedFromString(test_data.SITEMAPS_FEED) |
| self.assert_(len(feed.entry) == 3) |
| for entry in feed.entry: |
| self.assert_(entry, webmastertools.SitemapsEntry) |
| self.assert_(entry.sitemap_status, webmastertools.SitemapStatus) |
| self.assert_(entry.sitemap_last_downloaded, |
| webmastertools.SitemapLastDownloaded) |
| self.assert_(entry.sitemap_url_count, webmastertools.SitemapUrlCount) |
| self.assert_(entry.sitemap_status.text == 'StatusValue') |
| self.assert_(entry.sitemap_last_downloaded.text ==\ |
| '2006-11-18T19:27:32.543Z') |
| self.assert_(entry.sitemap_url_count.text == '102') |
| if entry.id.text == 'http://www.example.com/sitemap-index.xml': |
| self.assert_(entry.sitemap_type, webmastertools.SitemapType) |
| self.assert_(entry.sitemap_type.text == 'WEB') |
| self.assert_(entry.sitemap_mobile_markup_language is None) |
| self.assert_(entry.sitemap_news_publication_label is None) |
| elif entry.id.text == 'http://www.example.com/mobile/sitemap-index.xml': |
| self.assert_(entry.sitemap_mobile_markup_language, |
| webmastertools.SitemapMobileMarkupLanguage) |
| self.assert_(entry.sitemap_mobile_markup_language.text == 'HTML') |
| self.assert_(entry.sitemap_type is None) |
| self.assert_(entry.sitemap_news_publication_label is None) |
| elif entry.id.text == 'http://www.example.com/news/sitemap-index.xml': |
| self.assert_(entry.sitemap_news_publication_label, |
| webmastertools.SitemapNewsPublicationLabel) |
| self.assert_(entry.sitemap_news_publication_label.text == 'LabelValue') |
| self.assert_(entry.sitemap_type is None) |
| self.assert_(entry.sitemap_mobile_markup_language is None) |
| |
| |
| class SitemapsFeedTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.feed = gdata.webmastertools.SitemapsFeedFromString( |
| test_data.SITEMAPS_FEED) |
| |
| def testToAndFromString(self): |
| self.assert_(len(self.feed.entry) == 3) |
| for entry in self.feed.entry: |
| self.assert_(isinstance(entry, webmastertools.SitemapsEntry)) |
| new_feed = webmastertools.SitemapsFeedFromString(self.feed.ToString()) |
| self.assert_(len(new_feed.entry) == 3) |
| for entry in new_feed.entry: |
| self.assert_(isinstance(entry, webmastertools.SitemapsEntry)) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
