source: products/quintagroup.plonetabs/trunk/quintagroup/plonetabs/tests/test_controlpanel.py @ 917

Last change on this file since 917 was 917, checked in by crchemist, 17 years ago

Added test for testing order in meta tags.
File size: 20.0 KB
Line 
1import unittest
2
3from zope.interface import Interface
4from zope.interface.verify import verifyClass
5from zope.component import getMultiAdapter, provideAdapter
6
7from Products.CMFCore.utils import getToolByName
8from Products.CMFCore.ActionInformation import Action, ActionCategory
9
10from quintagroup.plonetabs import messageFactory as _
11from quintagroup.plonetabs.browser.interfaces import IPloneTabsControlPanel
12from quintagroup.plonetabs.browser.plonetabs import PloneTabsControlPanel as ptp
13from quintagroup.plonetabs.tests.base import PloneTabsTestCase
14from quintagroup.plonetabs.tests.data import PORTAL_ACTIONS
15
16class TestControlPanelHelperMethods(PloneTabsTestCase):
17    """Test here configlet helper methods"""
18   
19    def afterSetUp(self):
20        super(TestControlPanelHelperMethods, self).afterSetUp()
21        self.loginAsPortalOwner()
22        panel = getMultiAdapter((self.portal, self.portal.REQUEST),
23            name='plonetabs-controlpanel')
24        # we need this to apply zope2 security (got from zope2 traverse method)
25        self.panel = panel.__of__(self.portal)
26        self.tool = getToolByName(self.portal, 'portal_actions')
27   
28    def test_redirect(self):
29        response = self.portal.REQUEST.RESPONSE
30        method = self.panel.redirect
31        portal_url =  getMultiAdapter((self.portal, self.portal.REQUEST),
32                                      name=u"plone_portal_state").portal_url()
33        url = '%s/@@plonetabs-controlpanel' % portal_url
34        method()
35        self.assertEquals(response.headers.get('location', ''), url,
36            'Redirect method is not working properly.')
37       
38        # check query string and anchor hash
39        method('http://quintagroup.com', 'q=test', 'hash_code')
40        self.assertEquals(response.headers.get('location', ''),
41            'http://quintagroup.com?q=test#hash_code',
42            'Redirect method is not working properly.')
43   
44    def test_fixExpression(self):
45        method = self.panel.fixExpression
46        self.assertEquals(method('/slash'), 'string:${portal_url}/slash')
47        self.assertEquals(method('https://test.com'), 'string:https://test.com')
48        self.assertEquals(method('python:True'), 'python:True')
49        self.assertEquals(method('hello'), 'string:${object_url}/hello')
50   
51    def test_copyAction(self):
52        data = PORTAL_ACTIONS[0][1]['children'][0][1]
53        action = Action('act1', **data)
54        info = self.panel.copyAction(action)
55        self.assertEquals(len(info.keys()), 6)
56        self.assertEquals(info['description'], 'The most important place')
57   
58    def test_validateActionFields(self):
59        method = self.panel.validateActionFields
60        good_data = PORTAL_ACTIONS[0][1]['children'][0][1].copy()
61        good_data['id'] = 'new_one'
62        errors = method('new_category', good_data)
63        self.assertEquals(errors, {},
64            'There should be no errors for valid data.')
65       
66        bad_data = {'id':'',
67                    'title': ' ',
68                    'available_expr': 'bad_type:test',
69                    'url_expr': 'bad_type:test'}
70       
71        # Revert PloneTestCase's optimization
72        # because this breaks our test
73        def __init__(self, text):
74            self.text = text
75            if text.strip():
76                self._v_compiled = getEngine().compile(text)
77        from Products.CMFCore.Expression import Expression
78        optimized__init__ = Expression.__init__
79        Expression.__init__ = __init__
80        errors = method('new_category', bad_data)
81        # rollback our patch
82        Expression.__init__ = optimized__init__
83       
84        self.assertEquals(len(errors.keys()), 4,
85            'validateActionFields method is not working properly.')
86   
87    def test_processErrors(self):
88        method = self.panel.processErrors
89        errors = {'error':'error message'}
90        self.assertEquals(method(errors), errors,
91            'processErrors method is not working properly.')
92        self.assertEquals(method(errors, 'pre_', '_post'),
93            {'pre_error_post': 'error message'},
94            'processErrors method is not working properly.')
95   
96    def test_parseEditForm(self):
97        method = self.panel.parseEditForm
98        form = {'orig_id': 'id1',
99                'category': 'cat1',
100                'visible_id1': True,
101                'id_id1': 'id_new',
102                'title_id1': 'title1',
103                'url_expr_id1': 'expr1',
104                'available_expr_id1': 'expr2'}
105        self.assertEquals(method(form),
106            ('id1', 'cat1', {'id': 'id_new',
107                             'title': 'title1',
108                             'url_expr': 'expr1',
109                             'available_expr': 'expr2',
110                             'visible': True}),
111            'parseEditForm method is not working properly.')
112       
113        del form['orig_id']
114        self.failUnlessRaises(KeyError, method, form)
115   
116    def test_parseAddForm(self):
117        method = self.panel.parseAddForm
118        form = {'id': 'id1',
119                'category': 'cat1',
120                'visible': True,
121                'title': 'title1',
122                'url_expr': 'string:expr1',
123                'available_expr': 'expr2'}
124        self.assertEquals(method(form),
125            ('id1', 'cat1', {'id': 'id1',
126                             'visible': True,
127                             'title': 'title1',
128                             'url_expr': 'string:expr1',
129                             'available_expr': 'expr2'}),
130            'parseAddForm method is not working properly.')
131       
132        del form['id']
133        self.failUnlessRaises(KeyError, method, form)
134   
135    def test_getActionCategory(self):
136        method = self.panel.getActionCategory
137        self.purgeActions()
138        self.failUnlessRaises(KeyError, method, 'portal_tabs')
139       
140        self.setupActions(self.tool)
141        self.assertEquals(method('portal_tabs').id, 'portal_tabs',
142            'getActionCategory is not working properly.')
143   
144    def test_getOrCreateCategory(self):
145        method = self.panel.getOrCreateCategory
146        self.purgeActions()
147        self.assertEquals(method('portal_tabs').id, 'portal_tabs',
148            'getOrCreateCategory is not working properly.')
149   
150    def test_setSiteProperties(self):
151        self.panel.setSiteProperties(title='Test Title')
152        sp = getToolByName(self.portal, 'portal_properties').site_properties
153        self.assertEquals(sp.getProperty('title'), 'Test Title',
154            'setSiteProperties method is not working properly.')
155   
156    def test_renderViewlet(self):
157        # register test viewlet and it's manager
158        from zope.viewlet.interfaces import IViewlet, IViewletManager
159        from zope.viewlet.viewlet import ViewletBase
160        from zope.viewlet.manager import ViewletManagerBase
161        from zope.publisher.interfaces.browser import IDefaultBrowserLayer
162        from zope.publisher.interfaces.browser import IBrowserView
163        class TestViewlet(ViewletBase):
164            def __of__(self, obj):
165                return self
166            def render(self):
167                return 'test viewlet'
168        provideAdapter(
169            TestViewlet,
170            (Interface, IDefaultBrowserLayer, IBrowserView, IViewletManager),
171            IViewlet,
172            name=u'test_viewlet')
173        provideAdapter(
174            ViewletManagerBase,
175            (Interface, IDefaultBrowserLayer, IBrowserView),
176            IViewletManager,
177            name=u'test_manager')
178       
179        self.assertEquals(
180            self.panel.renderViewlet('test_manager', 'test_viewlet'),
181            'test viewlet',
182            'renderViewlet method is not workig properly')
183   
184    def test_addAction(self):
185        self.purgeActions()
186        self.panel.addAction('new_category', {'id':'id1', 'title':'Test'})
187        self.failUnless('id1' in self.tool.new_category.objectIds(),
188            'addAction method is not workig properly')
189   
190    def test_updateAction(self):
191        method = self.panel.updateAction
192       
193        self.purgeActions()
194        self.failUnlessRaises(KeyError, method, 'id1', 'cat1', {'id':'new'})
195       
196        self.setupActions(self.tool)
197        # we need to commit transaction because
198        # we are going to rename just added action now
199        import transaction
200        transaction.savepoint()
201        method('home', 'portal_tabs', {'id':'new_home'})
202        self.failUnless('new_home' in self.tool.portal_tabs.objectIds(),
203            'updateAction method is not workig properly')
204   
205    def test_deleteAction(self):
206        self.purgeActions()
207        self.setupActions(self.tool)
208        self.panel.deleteAction('home', 'portal_tabs')
209        self.failIf('home' in self.tool.portal_tabs.objectIds(),
210             'deleteAction method is not workig properly')
211   
212    def test_moveAction(self):
213        self.purgeActions()
214        self.setupActions(self.tool)
215        pos = self.tool.portal_tabs.getObjectPosition
216        self.assertEquals(pos('home'), 0,
217            'moveAction method is not workig properly')
218        self.panel.moveAction('home', 'portal_tabs', -1)
219        self.assertEquals(pos('home'), 1,
220             'moveAction method is not workig properly')
221
222
223class TestControlPanelAPIMethods(PloneTabsTestCase):
224    """Test here interface methods of control panel class"""
225   
226    def afterSetUp(self):
227        super(TestControlPanelAPIMethods, self).afterSetUp()
228        self.loginAsPortalOwner()
229        panel = getMultiAdapter((self.portal, self.portal.REQUEST),
230            name='plonetabs-controlpanel')
231        # we need this to apply zope2 security (got from zope2 traverse method)
232        self.panel = panel.__of__(self.portal)
233        self.tool = getToolByName(self.portal, 'portal_actions')
234   
235    def test_interface(self):
236        self.failUnless(IPloneTabsControlPanel.implementedBy(ptp),
237            'PloneTabs control panel does not implement required interface.')
238        self.failUnless(verifyClass(IPloneTabsControlPanel, ptp),
239            'PloneTabs control panel does not implement required interface.')
240   
241    def test_getPageTitle(self):
242        self.assertEquals(self.panel.getPageTitle(),
243            _(u"Portal Tabs Configuration"),
244            'getPageTitle method is broken')
245        self.assertEquals(self.panel.getPageTitle(category='notexists'),
246            _(u"Plone '${cat_name}' Configuration",
247              mapping={'cat_name': 'notexists'}),
248            'getPageTitle method is broken')
249   
250    def test_hasActions(self):
251        method = self.panel.hasActions
252        # purge any default portal actions
253        self.purgeActions()
254        self.failIf(method(),
255            'There should be no portal_tab actions in portal')
256       
257        # setup our own actions
258        self.setupActions(self.tool)
259        self.failUnless(method(),
260            'There should be portal_tab actions in portal')
261   
262    def test_getPortalActions(self):
263        method = self.panel.getPortalActions
264        # purge any default portal actions
265        self.purgeActions()
266        self.assertEquals(len(method()), 0,
267            'There should be no actions in portal_tabs category.')
268       
269        # setup our own actions
270        self.setupActions(self.tool)
271        self.assertEquals(len(method()), 2,
272            'There should be 2 actions in portal_tabs category.')
273       
274        # marginal arguments
275        self.assertEquals(len(method('notexistent_category')), 0,
276            'There should be no actions for not existed category.')
277   
278    def test_isGeneratedTabs(self):
279        method = self.panel.isGeneratedTabs
280        # prepare value
281        sp = getToolByName(self.portal, 'portal_properties').site_properties
282        sp.manage_changeProperties(disable_folder_sections=True)
283        self.failIf(method(), 'But folder sections are disabled...')
284   
285    def test_isNotFoldersGenerated(self):
286        method = self.panel.isNotFoldersGenerated
287        # prepare value
288        sp = getToolByName(self.portal, 'portal_properties').site_properties
289        sp.manage_changeProperties(disable_nonfolderish_sections=True)
290        self.failIf(method(), 'But non folderish sections are disabled...')
291   
292    def test_getActionsList(self):
293        method = self.panel.getActionsList
294        # purge any default portal actions
295        self.purgeActions()
296        self.failIf('class="editform"' in method(),
297            'There should no be actions in actions list template.')
298        self.setupActions(self.tool)
299        self.failUnless('class="editform"' in method(),
300            'There are no actions in actions list template.')
301   
302    def test_getAutoGenereatedSection(self):
303        method = self.panel.getAutoGenereatedSection
304        self.failIf('<form' in method('user'),
305            'There should be no form in autogenerated tabs template '
306            'for category other than portal_tabs.')
307        self.failUnless('<form' in method('portal_tabs'),
308            'There should be form in autogenerated tabs template '
309            'for portal_tabs category.')
310   
311    def test_getGeneratedTabs(self):
312        self.panel.getGeneratedTabs()
313        # check expiration header set by generated tabs template
314        self.assertEquals(
315            self.portal.REQUEST.RESPONSE.headers.get('expires', ''),
316            'Mon, 26 Jul 1996 05:00:00 GMT',
317            'Expiration header is not set properly.')
318   
319    def test_getRootTabs(self):
320        method = self.panel.getRootTabs
321        # make sure we don't depend on external settings
322        self.purgeContent()
323        self.assertEquals(len(method()), 0,
324            'There should be no root elements for navigation.')
325       
326        # now add some testing content
327        self.setupContent(self.portal)
328        self.assertEquals(len(method()), 2,
329            'There should be 2 elements in portal root for navigation.')
330       
331        # now switch off autogeneration
332        sp = getToolByName(self.portal, 'portal_properties').site_properties
333        sp.manage_changeProperties(disable_folder_sections=True)
334        self.assertEquals(len(method()), 0,
335            'There should be no root elements for navigation when '
336            'tabs autogeneration is switched off.')
337   
338    def test_getCategories(self):
339        method = self.panel.getCategories
340        # purge any default portal actions
341        self.purgeActions()
342        self.assertEquals(len(method()), 0,
343            'There should be no categories in portal_actions tool.')
344       
345        # now setup actions
346        self.setupActions(self.tool)
347        self.assertEquals(method(), ['portal_tabs', 'new_category'],
348            'There should be exactly 2 categories in portal_actions tool.')
349   
350    def test_portal_tabs(self):
351        method = self.panel.portal_tabs
352        self.purgeContent()
353        self.purgeActions()
354        self.assertEquals(len(method()), 0,
355            'There should be no portal tabs.')
356       
357        # cleanup memoize cache
358        # cause actions method of portal context state is caching it's
359        # results in request and we have the same request for every call
360        self.purgeCache(self.portal.REQUEST)
361       
362        # add actions
363        self.setupActions(self.tool)
364        self.assertEquals(len(method()), 2,
365            'There should be 2 portal tabs.')
366       
367        # add content
368        self.setupContent(self.portal)
369        self.assertEquals(len(method()), 4,
370            'There should be 4 portal tabs.')
371   
372    def test_selected_portal_tab(self):
373        self.assertEquals(self.panel.selected_portal_tab(), 'index_html',
374            'index_html is not selected tab while being on configlet.')
375
376    def test_test(self):
377        self.assertEquals(self.panel.test(True, 'true', 'false'), 'true',
378            'Test function does not work properly.')
379
380
381class TestControlPanelManageMethods(PloneTabsTestCase):
382    """Test here management methods of control panel class"""
383   
384    def afterSetUp(self):
385        super(TestControlPanelManageMethods, self).afterSetUp()
386        self.loginAsPortalOwner()
387        panel = getMultiAdapter((self.portal, self.portal.REQUEST),
388            name='plonetabs-controlpanel')
389        # we need this to apply zope2 security (got from zope2 traverse method)
390        self.panel = panel.__of__(self.portal)
391        self.tool = getToolByName(self.portal, 'portal_actions')
392       
393        # purge standard set of actions and set our own testing ones
394        self.purgeActions()
395        self.setupActions(self.tool)
396   
397    def test_manage_setAutogeneration(self):
398        self.setupContent(self.portal)
399        form = {'generated_tabs': '1',
400                'nonfolderish_tabs': '0',
401                'folder1': '0'}
402        self.panel.manage_setAutogeneration(form, {})
403        self.failUnless(self.portal.folder1.exclude_from_nav())
404        sp = getToolByName(self.portal, 'portal_properties').site_properties
405        self.failIf(sp.disable_folder_sections)
406        self.failUnless(sp.disable_nonfolderish_sections)
407   
408    def test_manage_addAction(self):
409        self.purgeActions()
410        form = {'id': 'id1',
411                'category': 'cat1',
412                'visible': True,
413                'title': 'title1',
414                'url_expr': 'string:expr1',
415                'available_expr': 'expr2'}
416        postback = self.panel.manage_addAction(form, {})
417        self.failUnless('id1' in self.tool.cat1.objectIds())
418        self.failIf(postback,
419            'There should be redirect after successfull adding.')
420   
421    def test_manage_editAction(self):
422        method = self.panel.manage_editAction
423        self.purgeActions()
424        self.setupActions(self.tool)
425        form = {'orig_id': 'home',
426                'category': 'portal_tabs',
427                'visible_home': True,
428                'id_home': 'id_new',
429                'title_home': 'title1',
430                'url_expr_home': 'expr1',
431                'available_expr_home': 'expr2'}
432        import transaction
433        transaction.savepoint()
434       
435        postback = method(form, {})
436        self.failUnless('id_new' in self.tool.portal_tabs.objectIds())
437        self.failIf(postback,
438            'There should be redirect after successfull edition.')
439       
440        form['category'] = 'non_existent'
441        self.failUnlessRaises(KeyError, method, form, {})
442   
443    def test_manage_deleteAction(self):
444        self.purgeActions()
445        self.setupActions(self.tool)
446        form = {'orig_id': 'home',
447                'category': 'portal_tabs',
448                'visible_home': True,
449                'id_home': 'id_new',
450                'title_home': 'title1',
451                'url_expr_home': 'expr1',
452                'available_expr_home': 'expr2'}
453        self.panel.manage_deleteAction(form, {})
454        self.failIf('home' in self.tool.portal_tabs.objectIds())
455   
456    def test_manage_moveUpAction(self):
457        self.purgeActions()
458        self.setupActions(self.tool)
459        form = {'orig_id': 'quintagroup',
460                'category': 'portal_tabs',
461                'visible_quintagroup': True,
462                'id_quintagroup': 'quintagroup',
463                'title_quintagroup': 'title1',
464                'url_expr_quintagroup': 'expr1',
465                'available_expr_quintagroup': 'expr2'}
466        self.panel.manage_moveUpAction(form, {})
467        self.assertEquals(
468            self.tool.portal_tabs.getObjectPosition('quintagroup'), 0)
469   
470    def test_manage_moveDownAction(self):
471        self.purgeActions()
472        self.setupActions(self.tool)
473        form = {'orig_id': 'home',
474                'category': 'portal_tabs',
475                'visible_home': True,
476                'id_home': 'home',
477                'title_home': 'title1',
478                'url_expr_home': 'expr1',
479                'available_expr_home': 'expr2'}
480        self.panel.manage_moveDownAction(form, {})
481        self.assertEquals(self.tool.portal_tabs.getObjectPosition('home'), 1)
482
483
484def test_suite():
485    suite = unittest.TestSuite()
486    suite.addTest(unittest.makeSuite(TestControlPanelHelperMethods))
487    suite.addTest(unittest.makeSuite(TestControlPanelAPIMethods))
488    suite.addTest(unittest.makeSuite(TestControlPanelManageMethods))
489   
490    # these tests are implemented as Selenium KSS Tests
491    # using kss.demo package, and KSS plugins are tested by means of
492    # ecmaunit.js
493    #suite.addTest(unittest.makeSuite(TestControlPanelKSSMethods))
494    return suite
Note: See TracBrowser for help on using the repository browser.