def test_theme_enabled_resource_directory(self):
app = self.layer['app']
portal = self.layer['portal']
self.settings.enabled = True
theme = getTheme('plone.app.theming.tests')
applyTheme(theme)
self.assertEqual(self.settings.rules, u'/++theme++plone.app.theming.tests/rules.xml')
self.assertEqual(self.settings.currentTheme, u"plone.app.theming.tests")
self.assertEqual(self.settings.doctype, u"<!DOCTYPE html>")
import transaction; transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
# Doctype
self.assertTrue(re.match("<!DOCTYPE html>\s+<html", browser.contents))
class AutoCSRFProtectTests(unittest.TestCase, _BaseAutoTest):
def setUp(self):
self.portal = self.layer['portal']
self.browser = Browser(self.layer['app'])
self.request = self.layer['request']
login(self.portal, TEST_USER_NAME)
self.browser.open(self.portal.absolute_url() + '/login_form')
self.browser.getControl(name='__ac_name').value = TEST_USER_NAME
self.browser.getControl(
name='__ac_password').value = TEST_USER_PASSWORD
self.browser.getControl(name='submit').click()
def open(self, path):
self.browser.open(self.portal.absolute_url() + '/' + path)
def test_CSRF_header(self):
self.request.environ['HTTP_X_CSRF_TOKEN'] = createToken()
view = AuthenticatorView(None, self.request)
self.assertEqual(view.verify(), True)
def test_incorrect_CSRF_header(self):
self.request.environ['HTTP_X_CSRF_TOKEN'] = 'foobar'
view = AuthenticatorView(None, self.request)
self.assertEqual(view.verify(), False)
def test_only_add_auth_when_user_logged_in(self):
logout()
self.open('logout')
self.open('test-unprotected')
try:
self.browser.getForm('one').getControl(name="_authenticator")
self.assertEqual('anonymous should not be protected', '')
except LookupError:
pass
def testquestion(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
import transaction
transaction.commit()
ques = portal['questionfolder']['question'].absolute_url()
browser.open(ques)
browser.getControl(name='form.submit').click()
open('/tmp/test.html','w').write(browser.contents)
self.assertTrue("question" in browser.contents)
self.assertTrue("question description" in browser.contents)
self.assertTrue("4" in browser.contents)
self.assertTrue("test_user_1_" in browser.contents)
self.assertTrue("defaultUser.png" in browser.contents)
self.assertTrue("answerone" in browser.contents)
self.assertTrue("answertwo" in browser.contents)
self.assertTrue("answerthree" in browser.contents)
self.assertTrue("add an answer" in browser.contents)
def test_theme_stored_in_plone_site(self):
app = self.layer['app']
portal = self.layer['portal']
# We'll upload the theme files to the Plone site root
rules_contents = open(
os.path.join(os.path.split(__file__)[0], 'localrules.xml')
)
theme_contents = open(
os.path.join(os.path.split(__file__)[0], 'theme.html')
)
portal.manage_addDTMLMethod('theme.html', file=theme_contents)
portal.manage_addDTMLMethod('rules.xml', file=rules_contents)
# These paths should be relative to the Plone site root
self.settings.rules = u'/rules.xml'
self.settings.enabled = True
import transaction
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
class NewsItemFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_add_news_item(self):
self.browser.open(self.portal_url)
self.browser.getLink('News Item').click()
self.assertTrue('Title' in self.browser.contents)
self.assertTrue('Description' in self.browser.contents)
self.assertTrue('Text' in self.browser.contents)
self.browser.getControl(name='form.widgets.IDublinCore.title')\
.value = "My news item"
self.browser.getControl(name='form.widgets.IDublinCore.description')\
.value = "This is my news item."
self.browser.getControl(name='form.widgets.text')\
.value = "Lorem Ipsum"
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-news-item/view'))
self.assertTrue('My news item' in self.browser.contents)
self.assertTrue('This is my news item' in self.browser.contents)
self.assertTrue('Lorem Ipsum' in self.browser.contents)
def test_view(self):
app = self.layer["app"]
portal = self.layer["portal"]
browser = Browser(app)
browser.handleErrors = False
browser.addHeader("Authorization", "Basic %s:%s" % (TEST_USER_ID, TEST_USER_PASSWORD))
import transaction
transaction.commit()
page = portal.absolute_url() + "/marketfolder1/marketpreview"
browser.open(page)
open("/tmp/test.html", "w").write(browser.contents)
# 我申请的会议
self.assertTrue("meetapply1" in browser.contents)
# 我申请的礼品
self.assertTrue("gift1" in browser.contents)
# 我申请的彩页
self.assertTrue("promotion1" in browser.contents)
# 部门费用
self.assertTrue("3" in browser.contents)
self.assertTrue("15000" in browser.contents)
# 地区拓展费用
self.assertTrue("爱数" in browser.contents)
self.assertTrue("1000.0" in browser.contents)
def test_render_plone_page(self):
app = self.layer['app']
portal = self.layer['portal']
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
self.assertTrue('<div id="wrapper">' in browser.contents)
def _workplace_inline_link_test(self, id_, label):
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (
SITE_OWNER_NAME, SITE_OWNER_PASSWORD))
portal_url = self.layer['portal'].portal_url()
browser.open('/'.join((portal_url, self.translated('workplace'))))
doc = PyQuery(browser.contents)
links = doc('#content .sl-text-wrapper a')
filtered_links = filter(
lambda node: node.text_content() == label,
links)
self.assertEquals(
len(filtered_links),
1,
'Expected one link "%s", but found: %s' % (
label,
str(map(lambda node: node.text_content(), filtered_links))))
self.assertEquals(
'/'.join((browser.url, id_)),
filtered_links[0].get('href'),
'Link "%s" seems to point to a wrong place.' % filtered_links[0].text_content())
class AutoRotateTests(unittest.TestCase):
layer = PROTECT_FUNCTIONAL_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.browser = Browser(self.layer['app'])
self.request = self.layer['request']
def test_keyrings_get_rotated_on_login(self):
manager = getUtility(IKeyManager)
ring = manager['_forms']
keys = ring.data
ring.last_rotation = 0
transaction.commit()
# should be rotated on login
login(self.portal, TEST_USER_NAME)
self.browser.open(self.portal.absolute_url() + '/login_form')
self.browser.getControl(name='__ac_name').value = TEST_USER_NAME
self.browser.getControl(
name='__ac_password').value = TEST_USER_PASSWORD
self.browser.getControl(name='submit').click()
self.assertNotEqual(keys, ring.data)
self.assertNotEqual(ring.last_rotation, 0)
class FolderFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_add_folder(self):
self.browser.open(self.portal_url)
self.browser.getLink(url='http://nohost/plone/++add++Folder').click()
self.browser.getControl(name='form.widgets.IDublinCore.title')\
.value = "My folder"
self.browser.getControl(name='form.widgets.IDublinCore.description')\
.value = "This is my folder."
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-folder/view'))
self.assertTrue('My folder' in self.browser.contents)
self.assertTrue('This is my folder' in self.browser.contents)
def test_publishing_a_hotfix_makes_it_visible_to_anonymous(self):
plonesite = self.layer["portal"]
workflow = plonesite.portal_workflow
login(plonesite, TEST_USER_NAME)
setRoles(plonesite, TEST_USER_ID, ["Manager", "Member"])
transaction.commit()
plonesite.invokeFactory('hotfix', 'h1', title=u"Hotfix 1")
transaction.commit()
hotfix = plonesite["h1"]
app = self.layer["app"]
browser = Browser(app)
browser.handleErrors = False
# Try navigating to a draft vulnerability as an Anonymous user
with self.assertRaises(Unauthorized):
browser.open(hotfix.absolute_url())
# Publish the vulnerability and try visiting it again
workflow.doActionFor(hotfix, 'publish')
transaction.commit()
browser.open(hotfix.absolute_url())
self.assertTrue(u"Hotfix 1" in browser.contents)
class LinkFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_add_link(self):
self.browser.open(self.portal_url)
self.browser.getLink('Link').click()
self.browser.getControl(name='form.widgets.IDublinCore.title')\
.value = 'My link'
self.browser.getControl(name='form.widgets.IDublinCore.description')\
.value = 'This is my link.'
self.browser.getControl(name='form.widgets.IShortName.id')\
.value = 'my-special-link'
self.browser.getControl(name='form.widgets.remoteUrl.external')\
.value = 'https://plone.org'
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-special-link/view'))
self.assertTrue('My link' in self.browser.contents)
self.assertTrue('This is my link' in self.browser.contents)
def test_render_home_page(self):
app = self.layer['app']
portal = self.layer['portal']
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
self.assertTrue('<!-- Theme home.html -->' in browser.contents)
class FileFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_add_pyfile(self):
self.browser.open(self.portal_url)
self.browser.getLink('CodeFile').click()
self.browser.getControl(name='form.widgets.title')\
.value = "My file"
self.browser.getControl(name='form.widgets.description')\
.value = "This is my file."
file_path = os.path.join(os.path.dirname(__file__), "temp.py")
file_ctl = self.browser.getControl(name='form.widgets.file')
file_ctl.add_file(open(file_path), 'image/png', 'temp.py')
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('temp.py/view'))
self.assertTrue('My file' in self.browser.contents)
self.assertTrue('This is my file' in self.browser.contents)
class TestAngularJsPortletNavigationFunctional(unittest.TestCase):
layer = PLONE_APP_ANGULARJS_FUNCTIONAL_TESTING
def setUp(self):
self.app = self.layer["app"]
self.portal = self.layer["portal"]
self.request = self.layer["request"]
from plone.testing.z2 import Browser
from plone.app.testing import SITE_OWNER_NAME
from plone.app.testing import SITE_OWNER_PASSWORD
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ["Manager"])
self.browser = Browser(self.app)
self.browser.handleErrors = False
self.browser.addHeader("Authorization", "Basic %s:%s" % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD))
def test_api_navigation_nested(self):
self.portal.invokeFactory("Folder", "news", title="News")
self.portal.news.invokeFactory("Folder", "news1", title="News 1")
import transaction
transaction.commit()
self.browser.open(self.portal_url + "/++api++v1/portlet_navigation?path=/news/news1")
output = json.loads(self.browser.contents)
self.assertEqual(output[0]["id"], u"news")
self.assertEqual(output[0]["children"][0]["id"], u"news1")
def test_navigate_save(self):
from zope.component import getUtility
from plone.registry.interfaces import IRegistry
from my315ok.products.interfaces import IMy315okProductsSettings
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
# Simulate HTTP Basic authentication
browser.addHeader('Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
# Open Plone's site setup
browser.open("%s/plone_control_panel" % portal.absolute_url())
# Go to the control panel
browser.getLink('My315okProducts settings').click()
# Edit the DAM codes field
browser.getControl(name='form.widgets.wordsNum').value = "32"
browser.getControl('Save').click()
# Verify that this made it into the registry
registry = getUtility(IRegistry)
settings = registry.forInterface(IMy315okProductsSettings)
self.assertEqual(settings.wordsNum,32)
def test_tag_filtering(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.open(portal.test.absolute_url() + '/search')
self.assertTrue('Test page title' in browser.contents)
self.assertFalse('<h1 id="test-title">' in browser.contents)
def test_reject_non_member(self):
# add user (username, strongpassword)
setRoles(self.portal, TEST_USER_ID, ['Manager'] )
self.acl_users.userFolderAddUser(username, strongpassword, [], [])
# setRoles(self.portal, TEST_USER_ID, ['Member'])
transaction.commit()
browser = Browser(self.app)
# we are not able to log in without Role "Member"
browserLogin(self.portal, browser, username, strongpassword)
self.assertFalse("logged in" in browser.contents)
browserLogin(self.portal, browser, TEST_USER_NAME, TEST_USER_PASSWORD)
login(self.portal, TEST_USER_NAME)
browser.open(self.portalURL+"/@@security-controlpanel")
browser.getControl(name='form.reject_non_members').value = False
browser.getControl(name='form.actions.save').click()
browser.open(self.portalURL + "/logout")
transaction.commit()
browser = Browser(self.app)
# now we are able to log in without Role "Member"
browserLogin(self.portal, browser, username, strongpassword)
self.assertTrue("logged in" in browser.contents)
class PAMFuncTestHelperViews(unittest.TestCase):
layer = PAM_FUNCTIONAL_TESTING
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
self.browser.addHeader('Authorization',
'Basic %s:%s' % (TEST_USER_NAME,
TEST_USER_PASSWORD))
self.settings = getUtility(IRegistry).forInterface(
ILanguageSchema,
prefix='plone')
def test_universal_link_view(self):
self.settings.use_request_negotiation = True
self.browser.addHeader('Accept-Language', 'ca')
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document")
a_en = api.translate(a_ca, 'en')
api.translate(a_ca, 'es')
transaction.commit()
self.browser.open(a_en.absolute_url())
self.browser.getLink("Universal link").click()
self.assertEqual(self.browser.url, a_ca.absolute_url())
def test_absolutePrefix_enabled_path_vhosting(self):
app = self.layer['app']
portal = self.layer['portal']
from Products.SiteAccess import VirtualHostMonster
VirtualHostMonster.manage_addVirtualHostMonster(app, 'virtual_hosting')
import transaction
transaction.commit()
self.settings.enabled = True
self.settings.absolutePrefix = u'/foo'
portalURL = portal.absolute_url()
prefix = '/'.join(portalURL.split('/')[:-1])
suffix = portalURL.split('/')[-1]
vhostURL = (
"{0:s}/VirtualHostBase/http/example.org:80/{1:s}/VirtualHostRoot"
"/_vh_fizz/_vh_buzz/_vh_fizzbuzz/".format(prefix, suffix)
)
import transaction
transaction.commit()
browser = Browser(app)
browser.open(vhostURL)
self.assertFalse('<img src="relative.jpg" />' in browser.contents)
self.assertTrue(
'<img src="/fizz/buzz/fizzbuzz/foo/relative.jpg" />'
in browser.contents
)
def test_barsview_mini(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
import transaction
transaction.commit()
page = portal.absolute_url() + '/orgnizationfolder1/@@barsview_mini'
url1 = portal.absolute_url() + '/orgnizationfolder1/orgnization1'
isrc1 = portal.absolute_url() + '/orgnizationfolder1/orgnization1' + "/@@images/image/mini"
title1= "Gif image"
url2 = portal.absolute_url() + '/orgnizationfolder1/orgnization2'
isrc2 = portal.absolute_url() + '/orgnizationfolder1/orgnization2' + "/@@images/image/mini"
title2= "Jpeg image"
url3 = portal.absolute_url() + '/orgnizationfolder1/orgnization3'
isrc3 = portal.absolute_url() + '/orgnizationfolder1/orgnization3' + "/@@images/image/mini"
title3= "Png image"
browser.open(page)
lookstr1 = '<div class="banner"><a href="%s"><img src="%s" alt="%s" /></a></div>' % (url1,isrc1,title1)
lookstr2 = '<div class="banner"><a href="%s"><img src="%s" alt="%s" /></a></div>' % (url2,isrc2,title2)
lookstr3 = '<div class="banner"><a href="%s"><img src="%s" alt="%s" /></a></div>' % (url3,isrc3,title3)
# import pdb
# pdb.set_trace()
self.assertTrue(lookstr1 in browser.contents)
self.assertTrue(lookstr2 in browser.contents)
self.assertTrue(lookstr3 in browser.contents)
class RichTextBehaviorFunctionalTest(RichTextBase, unittest.TestCase):
""" basic use cases and tests for richtext behavior"""
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
_behaviors = (
'plone.app.contenttypes.behaviors.richtext.IRichText',)
_portal_type = 'SomeDocument'
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.wf = getToolByName(self.portal, "portal_workflow")
self.portal.acl_users._doAddUser('user_std', 'secret', ['Member'], [])
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self._setupFTI()
self.portal.invokeFactory(self._portal_type, 'doc1')
setRoles(self.portal, TEST_USER_ID, ['Member'])
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_richtext_in_edit_form(self):
self.browser.open(self.portal_url + '/doc1/edit')
self.assertTrue('mce_editable' in self.browser.contents)
def test_richtext_behavior(self):
IRichText.providedBy(self.portal.doc1)
def test_uuid_view(self):
from plone.uuid.interfaces import IUUID
portal = self.layer['portal']
app = self.layer['app']
setRoles(portal, TEST_USER_ID, ['Manager'])
portal.invokeFactory('Document', 'd1')
d1 = portal['d1']
uuid = IUUID(d1)
import transaction
transaction.commit()
from plone.testing.z2 import Browser
browser = Browser(app)
browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(TEST_USER_ID, TEST_USER_PASSWORD, )
)
browser.open('{0}/@@uuid'.format(d1.absolute_url()))
self.assertEqual(uuid, browser.contents)
def test_theme_different_path(self):
app = self.layer['app']
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ('Manager',))
portal.invokeFactory('Folder', 'news', title=u"News")
setRoles(portal, TEST_USER_ID, ('Member',))
self.settings.enabled = True
import transaction; transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
browser.open(portal['news'].absolute_url())
# Title - pulled in with rules.xml
self.assertTrue("News" in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the other theme" in browser.contents)
def test_cache_without_GZIP(self):
ploneSettings = getUtility(IRegistry).forInterface(IPloneCacheSettings)
ploneSettings.enableCompression = False
app = self.layer['app']
portal = self.layer['portal']
# Folder content
setRoles(portal, TEST_USER_ID, ('Manager',))
portal.invokeFactory('Folder', 'f1')
portal['f1'].setTitle(u"Folder one")
portal['f1'].setDescription(u"Folder one description")
portal['f1'].reindexObject()
# Publish the folder
portal.portal_workflow.doActionFor(portal['f1'], 'publish')
import transaction
transaction.commit()
browser = Browser(app)
browser.open(portal['f1'].absolute_url())
# Title - pulled in with rules.xml
self.assertTrue(portal['f1'].Title() in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
def test_redirect_to_uuid_invalid_uuid(self):
from mechanize import HTTPError
portal = self.layer['portal']
app = self.layer['app']
setRoles(portal, TEST_USER_ID, ['Manager'])
portal.invokeFactory('Document', 'd1')
portal.invokeFactory('Document', 'd2')
import transaction
transaction.commit()
from plone.testing.z2 import Browser
browser = Browser(app)
browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(TEST_USER_ID, TEST_USER_PASSWORD, )
)
try:
url = '{0}/@@redirect-to-uuid/gibberish'
browser.open(url.format(portal.absolute_url()))
self.fail('No error raised')
except HTTPError, e:
self.assertEqual(e.code, 404)
class DocumentFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_add_document(self):
self.browser.open(self.portal_url)
self.browser.getLink(url='http://nohost/plone/++add++Document').click()
widget = 'form.widgets.IDublinCore.title'
self.browser.getControl(name=widget).value = 'My document'
widget = 'form.widgets.IDublinCore.description'
self.browser.getControl(name=widget).value = 'This is my document.'
widget = 'form.widgets.IRichTextBehavior.text'
self.browser.getControl(name=widget).value = 'Lorem Ipsum'
widget = 'form.widgets.IShortName.id'
self.browser.getControl(name=widget).value = 'my-special-document'
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-special-document/view'))
self.assertTrue('My document' in self.browser.contents)
self.assertTrue('This is my document' in self.browser.contents)
self.assertTrue('Lorem Ipsum' in self.browser.contents)
def test_tile_rendering(self):
try:
self.portal.invokeFactory('Folder', 'test-folder')
except:
self.portal.invokeFactory('Document', 'test-folder')
self.folder = self.portal['test-folder']
self.folder.invokeFactory('Document', 'd1')
d1 = self.folder.get('d1')
d1.setTitle(u'New title')
d1.text = RichTextValue(u"""\
<p>
<img
src="/++resource++collective.tinymcetiles.plugin/placeholder.gif"
alt="./@@dummy.tile/tile-1"
class="mceItem mceTile"
/>
</p>
""", 'text/html', 'text/x-html-safe', 'utf-8')
transaction.commit()
browser = Browser(self.portal)
browser.handleErrors = False
browser.open(d1.absolute_url())
self.assertIn('Test tile rendered', browser.contents)
self.assertIn('<p>With child tags</p>', browser.contents)
self.assertIn('And tail text', browser.contents)
class TestControlPanel(unittest.TestCase):
layer = THEMING_FUNCTIONAL_TESTING
def setUp(self):
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ['Manager'])
import transaction
transaction.commit()
self.portal = portal
self.browser = Browser(self.layer['app'])
handleErrors = self.browser.handleErrors
try:
self.browser.handleErrors = False
self.browser.open(portal.absolute_url() + '/login_form')
self.browser.getControl(name='__ac_name').value = TEST_USER_NAME
self.browser.getControl(name='__ac_password').value = TEST_USER_PASSWORD
self.browser.getControl(name='submit').click()
finally:
self.browser.handleErrors = handleErrors
def goto_controlpanel(self):
self.browser.open(self.portal.absolute_url() + '/@@theming-controlpanel')
def test_create_theme(self):
pass
class TestFunctional(FunctionalTestCase):
"""Full-blown browser tests for News Items."""
def setUp(self):
"""Custom shared utility setup for tests."""
self.portal = self.layer['portal']
self.browser = Browser(self.layer['app'])
self.browser.handleErrors = False
self.login() # login in self.browser so we can add content
# this has been failing for a long time but we didn't catch it on Travis
# moving on now, will come back to this at some later date
@unittest.expectedFailure
def test_image_is_required(self):
"""Try to add a News Item without an image."""
# go to add form
self.browser.open('http://nohost/plone/createObject?type_name=News+Item')
# fill in the title field (leave the rest empty)
self.browser.getControl('Title').value = u"Test item"
# click Save
self.browser.getControl('Save').click()
# check if `required` error is there
self.assertRegexpMatches(
self.browser.url,
'http://nohost/plone/portal_factory/News%20Item/news_item.[^/]+/atct_edit'
)
self.assertIn(
'Image is required, please correct.',
self.browser.contents
)
def test_zhifu_weixin_workflow_view(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
from zope.interface import alsoProvides
from xtcs.policy.interfaces import IJuanzengworkflow
alsoProvides(portal, IJuanzengworkflow)
import transaction
transaction.commit()
obj = portal.absolute_url() + '/@@donated_workflow'
browser.open(obj)
outstr = 'http://nohost/plone/@@hotauth'
self.assertTrue(outstr in browser.contents)
def test_renameObjectsByPaths(self):
PAYLOAD = {
'paths:list': '/plone/news',
# id must stay the same
'new_ids:list': 'news',
'new_titles:list': 'EVIL',
# Set orig_template to 'view'. Otherwise folder_rename "success" redirects
# to folder_contents, which will raise Unauthorized.
'orig_template': 'view',
}
browser = Browser(self.app)
csrf_token = self._get_authenticator()
PAYLOAD['_authenticator'] = csrf_token
# Call folder_rename anywhere
browser.open('http://nohost/plone/folder_rename', urlencode(PAYLOAD))
self.assertTrue(
'The following item(s) could not be renamed: /plone/news.' in
browser.contents)
self.assertEqual('News', self.portal.news.Title())
def test_theme_installed_invalid_config(self):
app = self.layer['app']
portal = self.layer['portal']
self.settings.enabled = True
self.settings.rules = u"invalid"
import transaction
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertTrue("Accessibility" in browser.contents)
# The theme
self.assertFalse("This is the theme" in browser.contents)
def test_theme_enabled_query_string_off_switch_production_mode(self):
app = self.layer['app']
portal = self.layer['portal']
Globals.DevelopmentMode = False
self.settings.enabled = True
import transaction
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url() + '?diazo.off=1')
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
def test_favorite_view(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
obj = portal['work1']['fa1'].absolute_url()
page = obj + '/@@view'
# import pdb
# pdb.set_trace()
browser.open(page)
outstr = '<div class="page-header">'
self.assertTrue(outstr in browser.contents)
def test_theme_params_on_404(self):
app = self.layer['app']
portal = self.layer['portal']
self.settings.enabled = True
self.settings.rules = u'python://plone.app.theming/tests/paramrules.xml'
self.settings.parameterExpressions = {
'stringParam': 'string:string param value',
'boolParam': 'python:False',
'contextParam' : 'context/absolute_url | string:no context',
'requestParam': 'request/someParam | string:off',
}
import transaction; transaction.commit()
browser = Browser(app)
error = None
try:
browser.open('%s/404_page' % portal.absolute_url())
except HTTPError, e:
error = e
def test_css_js_includes(self):
app = self.layer['app']
portal = self.layer['portal']
self.settings.enabled = True
self.settings.rules = u'/++theme++plone.app.theming.tests/css-js.xml'
import transaction
transaction.commit()
browser = Browser(app)
browser.open(portal.absolute_url())
# CSS - pulled in with rules
self.assertTrue('''<style type="text/css">/* A CSS file */\n</style>'''
in browser.contents)
# JS pulled in with rules
self.assertTrue(
'''<script type="text/javascript">/* A JS file */\n</script>''' in
browser.contents)
def test_menu_sublinks_rendered_in_correct_context(self):
"""
The menu link was rendered as a relative link, which means it generally
wasn't on the correct context. e.g. /news/@@cmsui-menu is the folder,
not the default view.
"""
browser = Browser(self.layer['app'])
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ('Member', 'Manager'))
document_id = portal.invokeFactory("Document",
"menu_test_context",
title="Context test")
document = portal[document_id]
# Commit so the change in roles is visible to the browser
transaction.commit()
browser_login(portal, browser)
browser.open(document.absolute_url())
browser.getLink("Manage page").click()
self.assertIn("menu_test_context", browser.url)
def test_navroot_params_on_404_widget_in_path(self):
app = self.layer['app']
portal = self.layer['portal']
portal.invokeFactory('Folder', 'subfolder')
self.settings.enabled = True
self.settings.parameterExpressions = {
'navigation_root_id':
'python:portal_state.navigation_root().getId()' # noqa
}
import transaction
transaction.commit()
browser = Browser(app)
error = None
try:
browser.open('{0:s}/widget/oauth_login/info.txt'.format(
portal['subfolder'].absolute_url()))
except HTTPError, e:
error = e
def test_inoutview(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
import transaction
transaction.commit()
page = portal.absolute_url() + '/@@datainout-controlpanel'
browser.open(page)
self.assertTrue(
'<input type="file" name="csv_upload" />' in browser.contents)
def test_front(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
import pdb
pdb.set_trace()
obj = portal.absolute_url() + '/@@index.html'
browser.open(obj)
outstr = u"图片新闻3"
self.assertTrue(outstr in browser.contents)
def test_auditview(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
page = portal['folder1']['project1']['team1']['audit1'].absolute_url(
) + '/@@view'
browser.open(page)
outstr = "here is rich text"
outstr2 = "this is report"
self.assertTrue(outstr in browser.contents)
self.assertTrue(outstr2 in browser.contents)
class EventFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization', 'Basic {0}:{1}'.format(
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
def test_add_event(self):
self.browser.open(self.portal_url)
self.browser.getLink('Event').click()
self.browser.getControl(
name='form.widgets.IDublinCore.title').value = 'My event'
self.browser.getControl(name='form.widgets.IDublinCore.description'
).value = 'This is my event.'
self.browser.getControl(
name='form.widgets.IRichTextBehavior.text').value = 'Lorem Ipsum'
self.browser.getControl(
name='form.widgets.IEventBasic.start').value = '2013-01-01'
self.browser.getControl(
name='form.widgets.IEventBasic.end').value = '2013-01-12'
self.browser.getControl(
name='form.widgets.IShortName.id').value = 'my-special-event'
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-special-event/view'))
self.assertIn('My event', self.browser.contents)
self.assertIn('This is my event', self.browser.contents)
self.assertIn('Lorem Ipsum', self.browser.contents)
self.assertIn('2013-01-01', self.browser.contents)
self.assertIn('2013-01-12', self.browser.contents)
class TestRequestAccess(unittest.TestCase):
layer = PLONE_LOGIN_FUNCTIONAL_TESTING
def setUp(self):
# Make sure our browserlayer is applied
alsoProvides(IPloneLoginLayer)
self.browser = Browser(self.layer['app'])
def test_insufficient_privileges_only_shows_access_button_when_site_can_send_email(
self): # noqa
mailhost = getUtility(IMailHost)
self.assertEqual(mailhost.smtp_host, '')
self.browser.open('http://nohost/plone/login')
self.browser.getControl('Login Name').value = TEST_USER_NAME
self.browser.getControl('Password').value = TEST_USER_PASSWORD
self.browser.getControl('Log in').click()
self.assertIn('You are now logged in', self.browser.contents)
self.browser.open('http://nohost/plone/@@overview-controlpanel')
self.assertIn('Insufficient Privileges', self.browser.contents)
self.assertNotIn('Request Access', self.browser.contents)
mailhost.smtp_host = 'localhost'
setattr(self.layer['portal'], 'email_from_address', '*****@*****.**')
transaction.commit()
self.browser.open('http://nohost/plone/@@overview-controlpanel')
self.assertIn('Insufficient Privileges', self.browser.contents)
self.assertIn('Request Access', self.browser.contents)
def test_theme_stored_in_plone_site_works_with_virtual_host(self):
app = self.layer['app']
portal = self.layer['portal']
# We'll upload the theme files to the Plone site root
rules_contents = open(
os.path.join(os.path.dirname(__file__), 'localrules.xml'))
theme_contents = open(
os.path.join(os.path.dirname(__file__), 'theme.html'))
portal.manage_addDTMLMethod('theme.html', file=theme_contents)
portal.manage_addDTMLMethod('rules.xml', file=rules_contents)
# These paths should be relative to the Plone site root
self.settings.rules = u'/rules.xml'
self.settings.enabled = True
from Products.SiteAccess import VirtualHostMonster
VirtualHostMonster.manage_addVirtualHostMonster(app, 'virtual_hosting')
import transaction
transaction.commit()
portalURL = portal.absolute_url()
prefix = '/'.join(portalURL.split('/')[:-1])
suffix = portalURL.split('/')[-1]
vhostURL = "%s/VirtualHostBase/http/example.org:80/%s/VirtualHostRoot/_vh_fizz/_vh_buzz/_vh_fizzbuzz/" % (
prefix, suffix)
browser = Browser(app)
browser.open(vhostURL)
# Title - pulled in with rules.xml
self.assertTrue(portal.title in browser.contents)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in browser.contents)
# The theme
self.assertTrue("This is the theme" in browser.contents)
def test_cache_with_GZIP_authenticated(self):
ploneSettings = getUtility(IRegistry).forInterface(IPloneCacheSettings)
ploneSettings.enableCompression = True
app = self.layer['app']
portal = self.layer['portal']
# Folder content
setRoles(portal, TEST_USER_ID, ('Manager', ))
portal.invokeFactory('Folder', 'f3')
portal['f3'].setTitle(u"Folder three")
portal['f3'].setDescription(u"Folder three description")
portal['f3'].reindexObject()
# Publish the folder
portal.portal_workflow.doActionFor(portal['f3'], 'publish')
import transaction
transaction.commit()
browser = Browser(app)
browser.addHeader('Accept-Encoding', 'gzip')
browser.addHeader('Authorization',
'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD))
browser.open(portal['f3'].absolute_url())
content_handler = cStringIO.StringIO(browser.contents)
uncompressed = gzip.GzipFile(fileobj=content_handler).read()
# Title - pulled in with rules.xml
self.assertTrue(portal['f3'].Title() in uncompressed)
# Elsewhere - not pulled in
self.assertFalse("Accessibility" in uncompressed)
# The theme
self.assertTrue("This is the theme" in uncompressed)
# headers
self.assertTrue('Accept-Encoding' in browser.headers['Vary'])
self.assertEqual('gzip', browser.headers['Content-Encoding'])
class LeadImageBehaviorFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
fti = DexterityFTI('leadimagefolder')
self.portal.portal_types._setObject('leadimagefolder', fti)
fti.klass = 'plone.dexterity.content.Container'
fti.behaviors = (
'plone.app.contenttypes.behaviors.leadimage.ILeadImage', )
self.fti = fti
alsoProvides(self.portal.REQUEST, IPloneAppContenttypesLayer)
alsoProvides(self.request, IPloneAppContenttypesLayer)
from plone.app.contenttypes.behaviors.leadimage import ILeadImage
alsoProvides(self.request, ILeadImage)
self.portal.invokeFactory('leadimagefolder',
id='leadimagefolder',
title=u'Folder with a lead image')
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization', 'Basic {0}:{1}'.format(
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
def test_lead_image_in_edit_form(self):
self.browser.open(self.portal_url + '/leadimagefolder/edit')
self.assertTrue('Lead Image' in self.browser.contents)
self.assertTrue('Lead Image Caption' in self.browser.contents)
def test_lead_image_viewlet_shows_up(self):
self.browser.open(self.portal_url + '/leadimagefolder/edit')
# Image upload
file_path = os.path.join(os.path.dirname(__file__), 'image.jpg')
file_ctl = self.browser.getControl(
name='form.widgets.ILeadImage.image')
file_ctl.add_file(io.FileIO(file_path), 'image/png', 'image.jpg')
# Image caption
self.browser.getControl(name='form.widgets.ILeadImage.image_caption'
).value = 'My image caption'
# Submit form
self.browser.getControl('Save').click()
self.assertTrue('My image caption' in self.browser.contents)
self.assertTrue('image.jpg' in self.browser.contents)
self.assertTrue('<div class="leadImage">' in self.browser.contents)
# But doesn't show up on folder_contents, which is not a default view
self.browser.open(self.portal_url + '/leadimagefolder/folder_contents')
self.assertTrue('<div class="leadImage">' not in self.browser.contents)
def test_resources(self):
import transaction
transaction.commit()
# Request a skin image
now = stable_now()
browser = Browser(self.app)
browser.open(self.portal.absolute_url() + '/rss.png')
self.assertEqual('plone.resource', browser.headers['X-Cache-Rule'])
self.assertEqual('plone.app.caching.strongCaching',
browser.headers['X-Cache-Operation'])
# This should use cacheInBrowserAndProxy
self.assertEqual('max-age=86400, proxy-revalidate, public',
browser.headers['Cache-Control'])
# remove this when the next line works
self.assertIsNotNone(browser.headers.get('Last-Modified'))
timedelta = dateutil.parser.parse(browser.headers['Expires']) - now
self.assertGreater(timedelta, datetime.timedelta(seconds=86390))
# Request the skin image again -- with an IMS header to test 304
lastmodified = browser.headers['Last-Modified']
browser = Browser(self.app)
browser.raiseHttpErrors = False
browser.addHeader('If-Modified-Since', lastmodified)
browser.open(self.portal.absolute_url() + '/rss.png')
self.assertEqual('plone.resource', browser.headers['X-Cache-Rule'])
self.assertEqual('plone.app.caching.strongCaching',
browser.headers['X-Cache-Operation'])
# This should be a 304 response
self.assertEqual('304 Not Modified', browser.headers['Status'])
self.assertEqual(b'', browser.contents)
# Request a large datafile (over 64K) to test files that use
# the "response.write()" function to initiate a streamed response.
# This is of type OFS.Image.File but it should also apply to
# large OFS.Image.Image, large non-blog ATImages/ATFiles, and
# large Resource Registry cooked files, which all use the same
# method to initiate a streamed response.
s = b'a' * (1 << 16) * 3
self.portal.manage_addFile(
'bigfile',
file=six.BytesIO(s),
content_type='application/octet-stream')
import transaction
transaction.commit()
browser = Browser(self.app)
browser.open(self.portal['bigfile'].absolute_url())
self.assertEqual('plone.resource', browser.headers['X-Cache-Rule'])
self.assertEqual('plone.app.caching.strongCaching',
browser.headers['X-Cache-Operation'])
# This should use cacheInBrowserAndProxy
self.assertEqual('max-age=86400, proxy-revalidate, public',
browser.headers['Cache-Control'])
# remove this when the next line works
self.assertIsNotNone(browser.headers.get('Last-Modified'))
timedelta = dateutil.parser.parse(browser.headers['Expires']) - now
self.assertGreater(timedelta, datetime.timedelta(seconds=86390))
def test_outbox(self):
browser = Browser(self.app)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (
'fromer',
'secret',
))
portalURL = self.portal.absolute_url()
browser.open(portalURL)
self.assertIn('fromer', browser.contents)
browser.open(portalURL + '/@@my_mailbox')
self.assertIn('*****@*****.**', browser.contents)
self.assertIn('*****@*****.**', browser.contents)
self.assertIn('Test subject 1', browser.contents)
self.assertIn('This is a mail body.', browser.contents)
self.assertIn('Test subject 2', browser.contents)
self.assertIn('The body\nof the mail.', browser.contents)
self.assertNotIn('*****@*****.**', browser.contents)
browser = Browser(self.app)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (
'toer',
'secret',
))
browser.open(portalURL + '/@@my_mailbox')
self.assertIn('*****@*****.**', browser.contents)
def test_virtual_hosting(self):
from Products.SiteAccess.VirtualHostMonster import manage_addVirtualHostMonster
from Products.SiteAccess.VirtualHostMonster import VirtualHostMonster
manage_addVirtualHostMonster(self.app)
self.assertTrue(VirtualHostMonster.id in self.app.objectIds())
self.portal.invokeFactory('Document', 'a_page')
self.assertTrue('a_page' in self.portal.objectIds())
self.portal.invokeFactory('Folder', 'a_folder')
self.assertTrue('a_folder' in self.portal.objectIds())
import transaction
transaction.commit()
browser = Browser(self.app)
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
url = self.app.absolute_url(
) + '/VirtualHostBase/http/www.buystuff.com:80/plone/a_page?MIGHT_REDIRECT=1'
browser.open(url)
self.assertEqual(url, browser.url)
url = self.app.absolute_url(
) + '/VirtualHostBase/http/www.buystuff.com:80/plone/a_folder/a_page?MIGHT_REDIRECT=1'
browser.open(url)
self.assertNotEqual(url, browser.url)
browser.handleErrors = False
url = self.app.absolute_url(
) + '/VirtualHostBase/http/www.buystuff.com:80/plone/VirtualHostRoot/_vh_z/a_page?MIGHT_REDIRECT=1'
browser.open(url)
self.assertEqual(url, browser.url)
class FolderFunctionalTest(unittest.TestCase):
layer = PLONE_APP_CONTENTTYPES_FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization', 'Basic %s:%s' % (
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
def test_add_folder(self):
self.browser.open(self.portal_url)
self.browser.getLink(url='http://nohost/plone/++add++Folder').click()
self.browser.getControl(name='form.widgets.IDublinCore.title')\
.value = "My folder"
# self.browser.getControl(name='form.widgets.IShortName.id')\
# .value = ""
self.browser.getControl(name='form.widgets.IDublinCore.description')\
.value = "This is my folder."
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-folder/view'))
self.assertTrue('My folder' in self.browser.contents)
self.assertTrue('This is my folder' in self.browser.contents)
@unittest.skip("IShortName not available")
def test_add_folder_with_shortname(self):
self.browser.open(self.portal_url)
self.browser.getLink(url='http://nohost/plone/++add++Folder').click()
self.browser.getControl(name='form.widgets.IDublinCore.title')\
.value = "My folder"
self.browser.getControl(name='form.widgets.IShortName.id')\
.value = "my-special-folder"
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-special-folder/view'))
class TestFieldCase(unittest.TestCase):
"""Test integration of collective.behavior.banner into Plone."""
layer = COLLECTIVE_BEHAVIOR_BANNER_FUNCTIONAL_TESTING
behaviors = ('collective.behavior.banner.banner.IBanner', )
portal_type = 'SomeDocument'
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.wf = api.portal.get_tool('portal_workflow')
self.portal.acl_users._doAddUser('user_std', 'secret', ['Member'], [])
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI(self.portal_type)
self.portal.portal_types._setObject(self.portal_type, fti)
fti.klass = 'plone.dexterity.content.Item'
fti.behaviors = self.behaviors
api.content.create(container=self.portal,
type=self.portal_type,
id='doc1')
setRoles(self.portal, TEST_USER_ID, ['Member'])
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization', 'Basic {0}:{1}'.format(
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
def test_some_banner_fields(self):
self.browser.open(self.portal_url + '/doc1/edit')
self.assertTrue('Banner' in self.browser.contents)
self.assertTrue('banner_fontcolor' in self.browser.contents)
self.assertTrue('banner_linktext' in self.browser.contents)
def test_add_to_portal_root_cancel(self):
browser = Browser(self.layer['app'])
browser.handleErrors = False
# Login
browser.open(self.portal.absolute_url() + '/login')
browser.getControl(name='__ac_name').value = TEST_USER_NAME
browser.getControl(name='__ac_password').value = TEST_USER_PASSWORD
browser.getControl('Log in').click()
# Enter the add screen for a temporary portal_factory-managed object
browser.open(self.portal.absolute_url() + '/++add++MyDocument')
# We should now have cookies with the drafts information
cookies = browser.cookies.forURL(browser.url)
self.assertEqual('"/plone"', cookies['plone.app.drafts.path'])
self.assertEqual( # noqa
'"%2B%2Badd%2B%2BMyDocument"',
cookies['plone.app.drafts.targetKey'],
)
self.assertNotIn(
'plone.app.drafts.draftName',
browser.cookies.forURL(browser.url),
)
# We can now cancel the edit. The cookies should expire.
browser.getControl(name='form.buttons.cancel').click()
self.assertNotIn(
'plone.app.drafts.targetKey',
browser.cookies.forURL(browser.url),
)
self.assertNotIn(
'plone.app.drafts.path',
browser.cookies.forURL(browser.url),
)
self.assertNotIn(
'plone.app.drafts.draftName',
browser.cookies.forURL(browser.url),
)
def test_todo_view(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
obj = portal['work1']['to1'].absolute_url()
page = obj + '/@@view'
browser.open(page)
outstr = '<tr class="row" data-toggle="tooltip"'
# import pdb
# pdb.set_trace()
self.assertTrue(outstr in browser.contents)
class AuthenticatedTestCase(unittest.TestCase):
"""Teste funcionais com usuário autenticado"""
layer = FUNCTIONAL_TESTING
def setUp(self):
Globals.DevelopmentMode = True
self.portal = self.layer['portal']
self.settings = getUtility(IRegistry).forInterface(IThemeSettings)
self.browser = Browser(self.layer['app'])
self.login_browser()
import transaction
transaction.commit()
def login_browser(self):
"""Autentica usuário de teste no browser"""
self.browser.handleErrors = False
basic_auth = 'Basic {0}'.format(
'{0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD)
)
self.browser.addHeader('Authorization', basic_auth)
def base_test(self, cor):
"""Teste base dos temas"""
theme = getTheme(cor)
applyTheme(theme)
self.settings.enabled = True
import transaction
transaction.commit()
# Testa se elementos do dashboard aparecem.
self.browser.open('{0}/dashboard'.format(self.portal.absolute_url()))
self.assertIn('id="kssPortalMessage"', self.browser.contents)
self.assertIn('dashboard</h1>', self.browser.contents)
# Testa se elementos da 'Informação Pessoal' aparecem.
self.browser.open('{0}/@@user-information?userid=admin'.format(
self.portal.absolute_url()))
self.assertIn('id="kssPortalMessage"', self. browser.contents)
self.assertIn('Change your personal information',
self.browser.contents)
# Testa se elementos da 'Preferências Pessoais' aparecem.
self.browser.open('{0}/@@user-preferences?userid=admin'.format(
self.portal.absolute_url()))
self.assertIn('id="kssPortalMessage"', self.browser.contents)
self.assertIn('Your personal settings', self.browser.contents)
def test_tema_verde_autenticado(self):
self.base_test('verde')
def test_tema_amarelo_autenticado(self):
self.base_test('amarelo')
def test_tema_branco_autenticado(self):
self.base_test('branco')
def test_tema_azul_autenticado(self):
self.base_test('azul')
class FileFunctionalTest(FunctionalTestCase):
layer = FUNCTIONAL_TESTING
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization', 'Basic %s:%s' % (
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
def test_add_file(self):
self.browser.open(self.portal_url)
self.browser.getLink('File').click()
self.assertTrue('Title' in self.browser.contents)
self.assertTrue('Description' in self.browser.contents)
self.browser.getControl(name='title')\
.value = "My file"
self.browser.getControl(name='description')\
.value = "This is my file."
file_path = os.path.join(os.path.dirname(__file__), "image.jpg")
file_ctl = self.browser.getControl(name='file_file')
file_ctl.add_file(open(file_path), 'image/png', 'image.jpg')
self.browser.getControl('Save').click()
self.assertTrue(self.browser.url.endswith('my-file/view'))
self.assertTrue('My file' in self.browser.contents)
self.assertTrue('This is my file' in self.browser.contents)
self.browser.getLink('image.jpg').click()
self.browser.open(self.portal_url)
self.browser.getLink('My file').click()
self.assertTrue('admin' in self.browser.contents)
self.browser.getLink('x').click()
def test_project_workflow(self):
# m/c/s/d chain
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
page = portal['folder1']['project1'].absolute_url() + '/@@view'
browser.open(page)
outstr = "submit to chuyang"
self.assertTrue(outstr in browser.contents)
wf = getToolByName(portal, 'portal_workflow')
wt = wf.emc_project_workflow
dummy = portal['folder1']['project1']
wf.notifyCreated(dummy)
chain = wf.getChainFor(dummy)
self.failUnless(chain[0] == 'emc_project_workflow')
review_state = wf.getInfoFor(dummy, 'review_state')
self.assertEqual(review_state, 'fangan')
wf.doActionFor(dummy, 'submit2chuyang', comment='submit to chu yang')
## available variants is actor,action,comments,time, and review_history
review_state = wf.getInfoFor(dummy, 'review_state')
self.assertEqual(review_state, 'chuyang')
comment = wf.getInfoFor(dummy, 'comments')
self.assertEqual(comment, 'submit to chu yang')
browser.open(page)
outstr = "submit to shiyang"
self.assertTrue(outstr in browser.contents)
wf.doActionFor(dummy, 'submit2shiyang', comment='submit to shiyang')
review_state = wf.getInfoFor(dummy, 'review_state')
self.assertEqual(review_state, 'shiyang')
comment = wf.getInfoFor(dummy, 'comments')
self.assertEqual(comment, 'submit to shiyang')
browser.open(page)
outstr = "submit to dingxing"
self.assertTrue(outstr in browser.contents)
wf.doActionFor(dummy, 'submit2dingxing', comment='submit to dingxing')
review_state = wf.getInfoFor(dummy, 'review_state')
self.assertEqual(review_state, 'dingxing')
comment = wf.getInfoFor(dummy, 'comments')
self.assertEqual(comment, 'submit to dingxing')
def test_available_workflow_transition_shown_in_workflow_panel(self):
browser = Browser(self.layer['app'])
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ('Member', 'Manager'))
document = createObject(portal,
"Document",
"transition_shown_in_workflow_panel_doc",
delete_first=True,
title="Workflow transitions")
# Commit so the change in roles is visible to the browser
transaction.commit()
browser_login(portal, browser)
browser.open(document.absolute_url())
browser.getLink("Manage page").click()
browser.getLink("Public draft").click()
# The submit button should be available
transitions = portal.portal_workflow.getTransitionsFor(document)
transition_ids = [transition['id'] for transition in transitions]
# Ensure the workflow transition we are going to look for in the
# workflow panel is actually available to save debugging headaches
# later
self.assertEqual(sorted(['submit', 'hide', 'publish']),
sorted(transition_ids))
# Make sure we have both labels and values for all possible workflow actions
workflow_actions = browser.getControl(
name="form.widgets.workflow_action:list")
self.assertEqual(len(workflow_actions.mech_control.items), 3)
self.assertEqual(
workflow_actions.getControl(
label='Submit for publication').optionValue, 'submit')
self.assertEqual(
workflow_actions.getControl(label='Make private').optionValue,
'hide')
self.assertEqual(
workflow_actions.getControl(label='Publish').optionValue,
'publish')
class RegistrationFunctionalTests(unittest.TestCase):
layer = PRODUCTS_EASYNEWSLETTER_FUNCTIONAL_TESTING
def setUp(self):
self.portal = self.layer["portal"]
self.portal_url = self.portal.absolute_url()
self.browser = Browser(self.portal)
self.browser.handleErrors = False
self.mail_settings = get_portal_mail_settings()
self.mail_settings.email_from_address = "*****@*****.**"
# Set up a mock mailhost
self.portal._original_MailHost = self.portal.MailHost
self.portal.MailHost = mailhost = MockMailHost("MailHost")
self.portal.MailHost.smtp_host = "localhost"
self.portal.MailHost.email_from_address = "*****@*****.**"
sm = getSiteManager(context=self.portal)
sm.unregisterUtility(provided=IMailHost)
sm.registerUtility(mailhost, provided=IMailHost)
# We need to fake a valid mail setup
# create EasyNewsletter instance and add some subscribers
setRoles(self.portal, TEST_USER_ID, ["Manager"])
# self.portal.portal_workflow.setDefaultChain(
# "simple_publication_workflow",
# )
self.portal.invokeFactory("Newsletter", "enl1", title="ENL 1")
self.newsletter = self.portal.get("enl1")
self.newsletter.senderEmail = "*****@*****.**"
self.newsletter.senderName = "ACME newsletter"
self.newsletter.testEmail = "*****@*****.**"
# Commit so that the test browser sees these changes
import transaction as zt
zt.commit()
def test_registration_portlet(self):
self.browser.open(self.newsletter.absolute_url())
def test_view_screening(self):
from Products.CMFCore.utils import getToolByName
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.open(portal['cinemas']['cinema1'].absolute_url())
browser.getLink('(show times)', index=0).click()
translation_service = getToolByName(portal, 'translation_service')
stamp = translation_service.ulocalized_time(
self.checkDate.isoformat(),
long_format=True,
context=portal,
domain='plonelocales',
)
self.assertTrue(stamp in browser.contents)
