source: products/quintagroup.plonegooglesitemaps/trunk/quintagroup/plonegooglesitemaps/tests/testSitemaps.py @ 3510

Last change on this file since 3510 was 3510, checked in by potar, 12 years ago

Merged sitemap_date branch into trunk

  • Property svn:eol-style set to native
File size: 15.6 KB
RevLine 
[2527]1#
2# Tests related to general Sitemap type.
3#
[3163]4from quintagroup.plonegooglesitemaps.tests.base \
5    import FunctionalTestCase, TestCase, IMobileMarker
6from StringIO import StringIO
7from urllib import urlencode
8import sys
9from XMLParser import hasURL
10import unittest
11
[2741]12from DateTime import DateTime
13from zope.interface import alsoProvides
14from zope.publisher.browser import TestRequest
15
[2533]16from Products.Archetypes import atapi
[2527]17from Products.CMFPlone.utils import _createObjectByType
18
[2741]19from quintagroup.plonegooglesitemaps.browser.sitemapview import SitemapView
[3152]20from quintagroup.plonegooglesitemaps.browser.newssitemapview \
21    import NewsSitemapView
22from quintagroup.plonegooglesitemaps.browser.mobilesitemapview \
23    import MobileSitemapView
[2527]24
[2741]25
[2527]26class TestSitemapType(FunctionalTestCase):
27
28    def afterSetUp(self):
29        super(TestSitemapType, self).afterSetUp()
[3152]30        self.contentSM = _createObjectByType('Sitemap', self.portal,
31                                             id='google-sitemaps')
[2527]32
33    def testFields(self):
[3152]34        field_ids = map(lambda x: x.getName(),
35                        self.contentSM.Schema().fields())
[2527]36        # test old Sitemap settings fields
37        self.assert_('id' in field_ids)
38        self.assert_('portalTypes' in field_ids)
39        self.assert_('states' in field_ids)
40        self.assert_('blackout_list' in field_ids)
41        self.assert_('urls' in field_ids)
42        self.assert_('pingTransitions' in field_ids)
43        # test new sitemap type field
44        self.assert_('sitemapType' in field_ids)
45
46    def testSitemapTypes(self):
[3152]47        sm_vocabulary = self.contentSM.getField('sitemapType').Vocabulary()
48        sitemap_types = sm_vocabulary.keys()
[2527]49        self.assert_('content' in sitemap_types)
50        self.assert_('mobile' in sitemap_types)
51        self.assert_('news' in sitemap_types)
52
53    def testAutoSetLayout(self):
[3510]54        response = self.publish('/%s/createObject?type_name=Sitemap'
[3152]55                                % self.portal.absolute_url(1), basic=self.auth)
[2527]56        location = response.getHeader('location')
[3152]57        newurl = location[location.find('/' + self.portal.absolute_url(1)):]
[2527]58
59        msm_id = 'mobile_sitemap'
60        form = {'id': msm_id,
[3152]61                'sitemapType': 'mobile',
62                'portalTypes': ['Document', ],
63                'states': ['published'],
64                'form_submit': 'Save',
65                'form.submitted': 1,
[2527]66                }
67        post_data = StringIO(urlencode(form))
[3152]68        response = self.publish(newurl, request_method='POST', stdin=post_data,
69                                basic=self.auth)
[2527]70        msitemap = getattr(self.portal, msm_id)
71
72        self.assertEqual(msitemap.defaultView(), 'mobile-sitemap.xml')
73
[3166]74    def testPingSetting(self):
[2527]75        self.assertEqual(self.contentSM.getPingTransitions(), ())
76
77        self.contentSM.setPingTransitions(('plone_workflow#publish',))
[3152]78        self.assertEqual(self.contentSM.getPingTransitions(),
79                         ('plone_workflow#publish',))
[2527]80
[2533]81    def testWorkflowStates(self):
82        wfstates = self.contentSM.getWorkflowStates()
83        self.assertEqual(isinstance(wfstates, atapi.DisplayList), True)
84        self.assertEqual("published" in wfstates.keys(), True)
[2527]85
[3163]86    def testWorkflowTransitions(self):
[2533]87        wftrans = self.contentSM.getWorkflowTransitions()
88        self.assertEqual(isinstance(wftrans, atapi.DisplayList), True)
[3510]89        self.assertEqual("simple_publication_workflow#publish" in
[3152]90                         wftrans.keys(), True)
[2533]91
[3002]92    def testSettingBlackout(self):
[3152]93        bolist = ["path:./el1  ", "   ", "", " id:index.html  ", "index_html"]
94        expect = ("path:./el1", "id:index.html", "index_html")
[3002]95        self.contentSM.edit(blackout_list=bolist)
96        value = self.contentSM.getBlackout_list()
[3510]97        self.assertTrue(value == expect, "Blackout list was not cleaned "
98                                         "up from whitespaces: %s"
99                                         % str(value))
[2533]100
[3002]101
[2527]102class TestSettings(FunctionalTestCase):
103
104    def afterSetUp(self):
105        super(TestSettings, self).afterSetUp()
[3152]106        gsm_properties = 'googlesitemap_properties'
107        self.gsm_props = self.portal.portal_properties[gsm_properties]
108        self.contentSM = _createObjectByType('Sitemap', self.portal,
109                                             id='google-sitemaps')
110        self.sitemapUrl = '/' + self.portal.absolute_url(1) + \
111                          '/google-sitemaps'
[2527]112        # Add testing document to portal
[2534]113        self.my_doc = _createObjectByType('Document', self.portal, id='my_doc')
[2527]114        self.my_doc.edit(text_format='plain', text='hello world')
115        self.my_doc_url = self.my_doc.absolute_url()
116
117    def testMetaTypeToDig(self):
118        self.workflow.doActionFor(self.my_doc, 'publish')
119        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
120        self.assert_(hasURL(sitemap, self.my_doc_url))
121
122        self.contentSM.setPortalTypes([])
123
124        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
125        self.assert_(not hasURL(sitemap, self.my_doc_url))
126
127        self.contentSM.setPortalTypes(['Document'])
128
129        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
130        self.assert_(hasURL(sitemap, self.my_doc_url))
131
132    def testStates(self):
133        self.workflow.doActionFor(self.my_doc, 'publish')
134        self.contentSM.setStates(['visible'])
135
136        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
137        self.assert_(not hasURL(sitemap, self.my_doc_url))
138
139        self.contentSM.setStates(['published'])
140
141        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
142        self.assert_(hasURL(sitemap, self.my_doc_url))
143
144    def test_blackout_entries(self):
145        self.workflow.doActionFor(self.my_doc, 'publish')
146        self.contentSM.setBlackout_list((self.my_doc.getId(),))
147
148        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
149        self.assert_(not hasURL(sitemap, self.my_doc_url))
150
151        self.contentSM.setBlackout_list([])
152        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
153        self.assert_(hasURL(sitemap, self.my_doc_url))
154
155    def test_regexp(self):
156        self.workflow.doActionFor(self.my_doc, 'publish')
157        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
158        self.assert_(not hasURL(sitemap, self.portal.absolute_url()))
159
[3152]160        regexp = "s/\/%s//" % self.my_doc.getId()
[2527]161        self.contentSM.setReg_exp([regexp])
162
163        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
164        self.assert_(hasURL(sitemap, self.portal.absolute_url()))
165
166    def test_add_urls(self):
167        self.contentSM.setUrls(['http://w1', 'w2', '/w3'])
168        w1_url = 'http://w1'
169        w2_url = self.portal.absolute_url() + '/w2'
170        w3_url = self.portal.getPhysicalRoot().absolute_url() + '/w3'
171        sitemap = self.publish(self.sitemapUrl, self.auth).getBody()
172
173        self.assert_(hasURL(sitemap, w1_url))
174        self.assert_(hasURL(sitemap, w2_url))
175        self.assert_(hasURL(sitemap, w3_url))
176
177
[2530]178class TestPinging(FunctionalTestCase):
179
180    def afterSetUp(self):
181        super(TestPinging, self).afterSetUp()
[3510]182        workflow = "simple_publication_workflow"
[3152]183        self.workflow.setChainForPortalTypes(pt_names=('News Item',
[3510]184                                                       'Document'),
185                                             chain=workflow)
[3152]186        gsm_properties = 'googlesitemap_properties'
187        self.gsm_props = self.portal.portal_properties[gsm_properties]
[2530]188        # Add sitemaps
[3152]189        self.contentSM = _createObjectByType('Sitemap', self.portal,
190                                             id='google-sitemaps')
191        spw_publish = 'simple_publication_workflow#publish'
192        self.contentSM.setPingTransitions((spw_publish,))
193        self.newsSM = _createObjectByType('Sitemap', self.portal,
194                                          id='news-sitemaps')
195        self.newsSM.setPortalTypes(('News Item', 'Document'))
196        self.newsSM.setPingTransitions((spw_publish,))
197        self.sitemapUrl = '/' + self.portal.absolute_url(1) + \
198                          '/google-sitemaps'
[2530]199        # Add testing document to portal
[2534]200        self.my_doc = _createObjectByType('Document', self.portal, id='my_doc')
[3152]201        self.my_news = _createObjectByType('News Item', self.portal,
202                                           id='my_news')
[2530]203
204    def testAutomatePinging(self):
205        # 1. Check for pinging both sitemaps
206        back_out, myout = sys.stdout, StringIO()
207        sys.stdout = myout
208        try:
209            self.workflow.doActionFor(self.my_doc, 'publish')
210            myout.seek(0)
211            data = myout.read()
212        finally:
213            sys.stdout = back_out
214
[3510]215        self.assert_('Pinged %s sitemap to Google'
[3152]216                     % self.contentSM.absolute_url() in data,
[2530]217                     "Not pinged %s: '%s'" % (self.contentSM.id, data))
[3510]218        self.assert_('Pinged %s sitemap to Google'
[3152]219                     % self.newsSM.absolute_url() in data,
[2530]220                     "Not pinged %s: '%s'" % (self.newsSM.id, data))
221
222        # 2. Check for pinging only news-sitemap sitemaps
223        back_out, myout = sys.stdout, StringIO()
224        sys.stdout = myout
225        try:
226            self.workflow.doActionFor(self.my_news, 'publish')
227            myout.seek(0)
228            data = myout.read()
229        finally:
230            sys.stdout = back_out
231
[3510]232        self.assert_('Pinged %s sitemap to Google'
[3152]233                     % self.newsSM.absolute_url() in data,
[2530]234                     "Not pinged %s: '%s'" % (self.newsSM.id, data))
[3510]235        self.assert_(not 'Pinged %s sitemap to Google'
[3152]236                     % self.contentSM.absolute_url() in data,
[2530]237                     "Pinged %s on news: '%s'" % (self.contentSM.id, data))
238
239    def testPingingWithSetupForm(self):
240        # Ping news and content sitemaps
[3152]241        formUrl = '/' + self.portal.absolute_url(1) + '/prefs_gsm_settings'
242        qs = 'smselected:list=%s&smselected:list=%s&form.button.Ping=1' \
243             '&form.submitted=1' % (self.contentSM.id, self.newsSM.id)
[2530]244
245        back_out, myout = sys.stdout, StringIO()
246        sys.stdout = myout
247        try:
[3163]248            self.publish("%s?%s" % (formUrl, qs), basic=self.auth)
[2530]249            myout.seek(0)
250            data = myout.read()
251        finally:
252            sys.stdout = back_out
253
[3510]254        self.assert_('Pinged %s sitemap to Google'
[3152]255                     % self.contentSM.absolute_url() in data,
[2530]256                     "Not pinged %s: '%s'" % (self.contentSM.id, data))
[3510]257        self.assert_('Pinged %s sitemap to Google'
[3152]258                     % self.newsSM.absolute_url() in data,
[2530]259                     "Not pinged %s: '%s'" % (self.newsSM.id, data))
260
261
[2741]262class TestContextSearch(TestCase):
263    """ Test if sitemaps collect objects from the container,
264        where it added to, but not from the portal root.
265    """
266    def prepareTestContent(self, smtype, ptypes, ifaces=()):
267        # Create test folder
268        tfolder = _createObjectByType("Folder", self.portal, id="test-folder")
269        # Add SiteMap in the test folder
270        self.sm = _createObjectByType("Sitemap", tfolder, id='sitemap',
271                                      sitemapType=smtype, portalTypes=ptypes)
272        self.sm.at_post_create_script()
273        # Add content in root and in the test folder
[3152]274        pubdate = (DateTime() + 1).strftime("%Y-%m-%d")
275        root_content = _createObjectByType(ptypes[0], self.portal,
276                                           id='root-content')
277        inner_content = _createObjectByType(ptypes[0], tfolder,
278                                            id='inner-content')
[2741]279        for obj in (root_content, inner_content):
280            self.workflow.doActionFor(obj, 'publish')
281            if ifaces:
282                alsoProvides(obj, ifaces)
[3152]283            obj.edit(effectiveDate=pubdate)  # this also reindex object
[2741]284        self.inner_path = '/'.join(inner_content.getPhysicalPath())
[3152]285
[2741]286    def testGoogleSitemap(self):
287        self.prepareTestContent("content", ("Document",))
288        filtered = SitemapView(self.sm, TestRequest()).getFilteredObjects()
[3152]289        self.assertEqual(map(lambda x: x.getPath(), filtered),
[3510]290                         [self.inner_path, ])
[2530]291
[2741]292    def testNewsSitemap(self):
293        self.prepareTestContent("news", ("News Item",))
294        filtered = NewsSitemapView(self.sm, TestRequest()).getFilteredObjects()
[3152]295        self.assertEqual(map(lambda x: x.getPath(), filtered),
296                         [self.inner_path, ])
[2741]297
298    def testMobileSitemap(self):
299        self.patchMobile()
300        self.prepareTestContent("content", ("Document",), (IMobileMarker,))
[3152]301        filtered = MobileSitemapView(self.sm,
302                                     TestRequest()).getFilteredObjects()
303        self.assertEqual(map(lambda x: x.getPath(), filtered),
304                         [self.inner_path, ])
[2741]305
306
[3510]307class TestSitemapDate(TestCase):
308    """ Method dedicated to test index (sitemap_date) in portal_catalog
309    """
310    def afterSetUp(self):
311        super(TestSitemapDate, self).afterSetUp()
312
313        from time import sleep
314
315        # sequence is important for testing
316        # ("test-folder1", "test-folder2", "index_html")
317        self.folder1 = _createObjectByType("Folder", self.portal,
318                                           id="test-folder1")
319
320        # create objects with different sitemap_date
321        sleep(1)
322        self.folder2 = _createObjectByType("Folder", self.folder1,
323                                           id="test-folder2")
324        sleep(1)
325        self.page = _createObjectByType("Document", self.folder2,
326                                        id="index_html")
327
328    def getCatalogSitemapDate(self, obj):
329        """ Method gets sitemap_date from portal_catalog """
330        return self.portal.portal_catalog(id=obj.id)[0].sitemap_date
331
332    def getIndexerSitemapDate(self, obj):
333        """  Method gets modification date from
334            function sitemap_date (indexer)
335        """
336        from quintagroup.plonegooglesitemaps.indexers import sitemap_date
337
338        modification_date = sitemap_date(obj)
339        # you have had to use '__call__' since Plone 3.3
340        if callable(modification_date):
341            modification_date = modification_date()
342        return modification_date
343
344    def testReindexParentObjects(self):
345        """ Method tests handler (reindexParentObjects) """
346        from quintagroup.plonegooglesitemaps.handlers \
347            import reindexParentObjects
348
349        # set default page
350        self.folder2.setDefaultPage("index_html")
351        reindexParentObjects(self.page, None)
352
353        self.assertEqual(self.getCatalogSitemapDate(self.page),
354                         self.getCatalogSitemapDate(self.folder2))
355        self.assertNotEqual(self.getCatalogSitemapDate(self.page),
356                            self.getCatalogSitemapDate(self.folder1))
357
358        # set default page
359        self.folder1.setDefaultPage("test-folder2")
360        reindexParentObjects(self.folder2, None)
361        self.assertEqual(self.getCatalogSitemapDate(self.page),
362                         self.getCatalogSitemapDate(self.folder1))
363
364    def testSitemapDateIndexer(self):
365        """ Method tests index (sitemap_date) """
366        last_date = self.getCatalogSitemapDate(self.folder1)
367        self.assertEqual(last_date, self.getIndexerSitemapDate(self.folder1))
368        self.folder1.setDefaultPage("test-folder2")
369        self.assertNotEqual(last_date,
370                            self.getIndexerSitemapDate(self.folder1))
371
372
[2527]373def test_suite():
[3163]374    suite = unittest.TestSuite()
375    suite.addTest(unittest.makeSuite(TestSitemapType))
376    suite.addTest(unittest.makeSuite(TestSettings))
377    suite.addTest(unittest.makeSuite(TestPinging))
378    suite.addTest(unittest.makeSuite(TestContextSearch))
[3510]379    suite.addTest(unittest.makeSuite(TestSitemapDate))
[2527]380    return suite
381
382if __name__ == '__main__':
383    unittest.main(defaultTest='test_suite')
384#    framework()
Note: See TracBrowser for help on using the repository browser.