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_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_tile_rendering(self):
self.portal.invokeFactory('Folder', 'test-folder')
self.folder = self.portal['test-folder']
self.folder.invokeFactory('Document', 'd1')
self.folder['d1'].setTitle(u"New title")
self.folder['d1'].setText(u"""\
<p>
<img
src="/++resource++collective.tinymcetiles.plugin/placeholder.gif"
alt="./@@dummy.tile/tile-1"
class="mceItem mceTile"
/>
</p>
""")
self.folder['d1'].getField('text').setContentType(self.folder['d1'],
"text/html")
# pw = getToolByName(self.portal, 'portal_workflow')
# pw.doActionFor(self.folder['d1'], 'publish')
transaction.commit()
browser = Browser(self.portal)
browser.handleErrors = False
browser.open(self.folder['d1'].absolute_url())
self.failUnless("Test tile rendered" in browser.contents)
self.failUnless("<p>With child tags</p>" in browser.contents)
self.failUnless("And tail text" in browser.contents)
def test_send_subscriber(self):
self.gfolder.invokeFactory('gazette.GazetteIssue', 'issue')
issue = self.gfolder['issue']
issue.title = u'Test issue'
issue.text = RichTextValue('Hello world!')
request = self.request
adapter = getMultiAdapter((self.gfolder, request), IGazetteSubscription)
adapter.subscribe('*****@*****.**', '')
# activation message
self.failUnless(len(self.mailhost.messages) == 1)
# Activate subsriber
soup = getSoup(self.context, config.SUBSCRIBERS_SOUP_ID)
s = soup.query(email='*****@*****.**').next()
s.active = True
s.key = u''
soup.reindex([s])
transaction.commit()
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.open(issue.absolute_url() + '/send')
self.failUnless('Number of subscribers: 1' in browser.contents)
browser.getControl(name='submit').click()
self.failUnless('Gazette has been sent to 1 recipients' in browser.contents)
# activation + issue
self.failUnless(len(self.mailhost.messages) == 2)
def test_myanswer(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()
setRoles(portal, TEST_USER_ID, ('Manager',))
m9 =portal.absolute_url()+'/@@myanswer'
# import pdb
# pdb.set_trace()
# browser.open(portal.absolute_url())
# browser.open("%s/@@dam-report" % portal.absolute_url())
browser.open( m9)
open('/tmp/test.html','w').write(browser.contents)
# self.assertTrue("3" in browser.contents)
self.assertTrue("monst" in browser.contents)
self.assertTrue("fast" in browser.contents)
self.assertTrue("Next" in browser.contents)
def test_existing_content_tile_private(self):
"""When the current user does not have enough permissions to view
the content linked to existing content tile, the tile renders
empty"""
self.portal.portal_workflow.setDefaultChain(
'simple_publication_workflow')
page_id = self.portal.invokeFactory(
'Document', 'an-another-page',
title=u'An another page', description=u'A description',
text=u'Hello World!'
)
self.portal[page_id].text = RichTextValue(u'Hello World!')
page_uuid = IUUID(self.portal[page_id])
transaction.commit()
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(
self.portalURL +
'/@@plone.app.standardtiles.existingcontent/unique?content_uid=' +
page_uuid
)
self.assertNotIn(u'Hello World!', browser.contents)
self.assertIn(u'<body></body>', browser.contents)
def test_collection_templates(self):
data = getData('image.png')
# add an image that will be listed by the collection
self.portal.invokeFactory("Image",
"image",
title="Image example",
image=data)
# Search for images
query = [{
'i': 'Type',
'o': 'plone.app.querystring.operation.string.is',
'v': 'Image',
}]
# set the query and publish the collection
self.collection.setQuery(query)
commit()
logout()
# open a browser to see if our image is in the results
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open summary_view template
browser.open('%s/summary_view' % self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open folder_summary_view template
browser.open('%s/folder_summary_view' % self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open thumbnail_view template
browser.open('%s/thumbnail_view' % self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
def test_redirect_to_uuid_invalid_uuid(self):
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.handleErrors = False
browser.addHeader(
'Authorization', 'Basic {0}:{1}'.format(
TEST_USER_ID,
TEST_USER_PASSWORD,
))
url = '{0}/@@redirect-to-uuid/gibberish'
from zope.publisher.interfaces import NotFound
with self.assertRaises(NotFound):
browser.open(url.format(portal.absolute_url()))
def test_edit(self):
browser = Browser(self.layer['app'])
browser.handleErrors = False
self.folder.invokeFactory('MyDocument', 'd1')
self.folder['d1'].title = u"New title"
transaction.commit()
uuid = IUUID(self.folder['d1'])
# 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 edit screen
browser.open(self.folder['d1'].absolute_url() + '/edit')
# We should now have cookies with the drafts information
cookies = browser.cookies.forURL(browser.url)
self.assertEquals('"%s"' % self.folder['d1'].absolute_url_path(), cookies['plone.app.drafts.path'])
self.assertEquals('"%s"' % uuid, cookies['plone.app.drafts.targetKey'])
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
# We can now save the page. The cookies should expire.
browser.getControl(name='form.buttons.save').click()
self.failIf('plone.app.drafts.targetKey' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.path' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
def test_add_to_folder(self):
browser = Browser(self.layer['app'])
browser.handleErrors = False
uuid = IUUID(self.folder)
# 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.folder.absolute_url() + '/portal_factory/Document/document.2010-02-04.2866363923/edit')
# Confirm pass CSRF protection
try:
browser.getControl(name='form.button.confirm').click()
except LookupError:
pass
# We should now have cookies with the drafts information
cookies = browser.cookies.forURL(browser.url)
self.assertEquals(
'"%s/portal_factory/Document/document.2010-02-04.2866363923"' % self.folder.absolute_url_path(),
cookies['plone.app.drafts.path']
)
self.assertEquals('"%s%%3ADocument"' % uuid, cookies['plone.app.drafts.targetKey'])
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
# We can now cancel the edit. The cookies should expire.
browser.getControl(name='form.button.cancel').click()
self.failIf('plone.app.drafts.targetKey' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.path' in browser.cookies.forURL(browser.url))
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_NAME,
TEST_USER_PASSWORD,
))
import transaction
transaction.commit()
obj = portal.absolute_url() + '/nashuiku1/nashuiren1'
page = obj + '/@@nashuiren_view'
browser.open(page)
# open('/tmp/test.html', 'w').write(browser.contents)
outstr = '<span>888202</span>'
self.assertTrue(outstr in browser.contents)
outstr = 'data-property="yinhuashui"'
self.assertTrue(outstr in browser.contents)
outstr = '<td class="col-md-1 text-center">0</td>'
self.assertTrue(outstr in browser.contents)
def test_add_to_folder(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.folder.absolute_url() + '/++add++MyDocument')
# We should now have cookies with the drafts information
cookies = browser.cookies.forURL(browser.url)
self.assertEquals(
'"%s"' % self.folder.absolute_url_path(),
cookies['plone.app.drafts.path']
)
self.assertEquals('"%2B%2Badd%2B%2BMyDocument"', cookies['plone.app.drafts.targetKey'])
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
# We can now cancel the edit. The cookies should expire.
browser.getControl(name='form.buttons.cancel').click()
self.failIf('plone.app.drafts.targetKey' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.path' in browser.cookies.forURL(browser.url))
def test_select_or_upload_invariant(self):
portal = self.layer['portal']
browser = Browser(portal)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.open('http://nohost/plone/test-repository/++add++collective.chimpdrill.template')
# No values filled in
browser.getControl(name='form.buttons.save').click()
self.assertEqual("http://nohost/plone/test-repository/++add++collective.chimpdrill.template", browser.url)
self.assertTrue('You must either select a Mailchimp Template or provide a name and template code to create a new template' in browser.contents)
# No template, title, no template code, should fail
browser.getControl(name='form.widgets.upload_title').value = "Test Template 3"
browser.getControl(name='form.widgets.description').value = u"Test Upload Description"
browser.getControl(name='form.buttons.save').click()
self.assertEqual("http://nohost/plone/test-repository/++add++collective.chimpdrill.template", browser.url)
self.assertTrue('You must either select a Mailchimp Template or provide a name and template code to create a new template' in browser.contents)
# No template, no title, template code, should fail
browser.getControl(name='form.widgets.upload_title').value = ""
browser.getControl(name='form.widgets.template_code').value = MC_TEMPLATE_HTML
browser.getControl(name='form.widgets.description').value = u"Test Upload Description"
browser.getControl(name='form.buttons.save').click()
self.assertEqual("http://nohost/plone/test-repository/++add++collective.chimpdrill.template", browser.url)
self.assertTrue('You must either select a Mailchimp Template or provide a name and template code to create a new template' in browser.contents)
def test_create_new_template(self):
portal = self.layer['portal']
browser = Browser(portal)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.open('http://nohost/plone/test-repository/++add++collective.chimpdrill.template')
browser.getControl(name='form.widgets.upload_title').value = "Test Template 3"
browser.getControl(name='form.widgets.template_code').value = MC_TEMPLATE_HTML
browser.getControl(name='form.widgets.description').value = u"Test Upload Description"
browser.getControl(name='form.widgets.email_subject').value = u"Test Template 3 Subject"
browser.getControl(name='form.widgets.from_email').value = u"*****@*****.**"
browser.getControl(name='form.widgets.from_name').value = u"Jack Black"
browser.getControl(name='form.buttons.save').click()
self.assertEqual("http://nohost/plone/test-repository/test-template-3/view", browser.url)
self.assertTrue('Test Template 3' in browser.contents)
self.assertTrue('Test Upload Description' in browser.contents)
template = portal.unrestrictedTraverse('test-repository/test-template-3')
self.assertEqual(template.mandrill_template, 'mailchimp-3')
self.assertEqual(template.mandrill_template_info['name'], 'mailchimp-3')
self.assertEqual(template.mailchimp_template_info['name'], 'Test Template 3')
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.open('http://nohost/plone/test-repository/test-template-3/preview')
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.open('http://nohost/plone/test-repository/test-template-3/send_email')
browser.getControl(name='form.widgets.send_to')
def anonymous_browser(self):
"""Browser of anonymous
"""
from plone.testing.z2 import Browser
browser = Browser(self['app'])
browser.handleErrors = False
return browser
def test_edit_multiple_existing_drafts(self):
browser = Browser(self.layer['app'])
browser.handleErrors = False
self.folder.invokeFactory('Document', 'd1')
self.folder['d1'].setTitle(u'New title')
transaction.commit()
uuid = IUUID(self.folder['d1'])
# Create two drafts for this object - we don't expect either to be used
storage = getUtility(IDraftStorage)
storage.createDraft(TEST_USER_ID, str(uuid))
storage.createDraft(TEST_USER_ID, str(uuid))
# 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 edit screen
browser.open(self.folder['d1'].absolute_url() + '/edit')
# Confirm pass CSRF protection
try:
browser.getControl(name='form.button.confirm').click()
except LookupError:
pass
# We should now have cookies with the drafts information
cookies = browser.cookies.forURL(browser.url)
self.assertEqual(
'"{0}"'.format(self.folder['d1'].absolute_url_path()),
cookies['plone.app.drafts.path'],
)
self.assertEqual(
'"{0}"'.format(uuid),
cookies['plone.app.drafts.targetKey'],
)
self.assertNotIn(
'plone.app.drafts.draftName',
browser.cookies.forURL(browser.url),
)
# We can now save the page. The cookies should expire.
browser.getControl(name='form.button.save').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_functional(self):
""" """
portal = self.layer['portal']
app = self.layer['app']
browser = Browser(app)
browser.handleErrors = False
self.register_users()
login(portal, TEST_USER_NAME)
setRoles(portal, TEST_USER_ID, ('Manager',))
id = portal.invokeFactory(
'Event',
'plone-conference',
title='Plone Conference')
transaction.commit()
browser.open(portal.absolute_url() + '/login_form')
browser.getControl(name='__ac_name').value = TEST_USER_NAME
browser.getControl(name='__ac_password').value = TEST_USER_PASSWORD
browser.getControl(name='submit').click()
browser.open('%s/@@invite-attendees' % portal['plone-conference'].absolute_url())
# XXX: Can't set the value of the UserAndGroupSelectionWidget because the <select>
# doesn't have any <option> elements to choose from. Instead it's populated via
# javascript which we cannot do via zc.testbrowser.
att = browser.getControl(name="form.widgets.internal_attendees:list")
name = browser.getControl(name='form.widgets.external_attendees.AA.widgets.name')
email = browser.getControl(name='form.widgets.external_attendees.AA.widgets.email')
email_all = browser.getControl(name="form.buttons.email_all")
def test_add_to_portal_root_save(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.assertEquals('"/plone"', cookies['plone.app.drafts.path'])
self.assertEquals('"%2B%2Badd%2B%2BMyDocument"', cookies['plone.app.drafts.targetKey'])
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
# We can now fill in the required fields and save. The cookies should expire.
browser.getControl(name='form.widgets.IDublinCore.title').value = u"New Document"
browser.getControl(name='form.buttons.save').click()
self.failIf('plone.app.drafts.targetKey' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.path' in browser.cookies.forURL(browser.url))
self.failIf('plone.app.drafts.draftName' in browser.cookies.forURL(browser.url))
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)
def test_publishing_a_vulnerability_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()
# Allow vulnerabilities to be added to the site root
fti = plonesite.portal_types['vulnerability']
fti.global_allow = True
transaction.commit()
vulnerability = createContentInContainer(plonesite, 'vulnerability', title=u"Vulnerability 1")
transaction.commit()
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(vulnerability.absolute_url())
# Publish the vulnerability and try visiting it again
workflow.doActionFor(vulnerability, 'publish')
transaction.commit()
browser.open(vulnerability.absolute_url())
self.assertTrue(u"Vulnerability 1" in browser.contents)
def test_workbook_browser_import(self):
"""
A workbook can be imported in the browser.
"""
import transaction
transaction.commit()
from plone.testing.z2 import Browser
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(self.portal.absolute_url() + '/login_form')
browser.getControl(
name='__ac_name').value = pa_testing.SITE_OWNER_NAME
browser.getControl(
name='__ac_password').value = pa_testing.SITE_OWNER_PASSWORD
browser.getControl(name='submit').click()
import mimetypes
browser.open(self.portal.absolute_url() + '/workbook-import')
workbook_ctrl = browser.getControl(name='form.widgets.workbook')
workbook_ctrl.add_file(
open(self.workbook_path),
mimetypes.guess_type(self.workbook_path)[0],
os.path.basename(self.workbook_path))
self.assertNotIn(
'foo-document-title', self.portal,
'Content exists before importing')
browser.getControl('Import').click()
self.assertIn(
'foo-document-title', self.portal,
'Content not created from import')
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)
def test_existing_content_tile_private(self):
"""When the current user does not have enough permissions to view
the content linked to existing content tile, the tile renders
empty"""
self.portal.portal_workflow.setDefaultChain(
'simple_publication_workflow')
page_id = self.portal.invokeFactory('Document',
'an-another-page',
title=u'An another page',
description=u'A description',
text=u'Hello World!')
self.portal[page_id].text = RichTextValue(u'Hello World!')
page_uuid = IUUID(self.portal[page_id])
transaction.commit()
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(
self.portalURL +
'/@@plone.app.standardtiles.existingcontent/unique?content_uid=' +
page_uuid)
self.assertNotIn(u'Hello World!', browser.contents)
self.assertIn(u'<body></body>', browser.contents)
def testtopicfollowView(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
import transaction
transaction.commit()
event.notify(FollowedEvent(self.q1))
event.notify(FollowedEvent(self.q2))
event.notify(FollowedEvent(self.q3))
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
import transaction
transaction.commit()
questionfollowed = portal.absolute_url() + '/@@followed'
browser.open(questionfollowed)
self.assertTrue("questionone" in browser.contents)
self.assertTrue("questiontwo" in browser.contents)
self.assertTrue("questionthree" in browser.contents)
self.assertTrue("col-md-2 unfollow" in browser.contents)
event.notify(FollowedEvent(self.t1))
event.notify(FollowedEvent(self.t2))
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
import transaction
transaction.commit()
browser.open(portal.absolute_url() + "/@@topicfollowed")
self.assertTrue("topicone" in browser.contents)
self.assertTrue("topictwo" in browser.contents)
def testpersonalhomepageView(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()
event.notify(FollowedEvent(self.t1))
event.notify(FollowedEvent(self.t2))
event.notify(FollowedEvent(self.q3))
intids = getUtility(IIntIds)
portal['folder']['questionfolder']['question3'].invokeFactory('emc.kb.answer', 'answer5',
content=u"answerfour"
)
portal['folder']['questionfolder'].invokeFactory('emc.kb.question', 'question4',
title='questionfour',
affiliatedtopics=[RelationValue(intids.getId(self.t1))],
)
q4 = portal['folder']['questionfolder']['question4']
event.notify(FollowedEvent(q4))
import transaction
transaction.commit()
browser.open(portal['folder']['feedsfolder'].absolute_url())
self.assertTrue("questionthree" in browser.contents)
self.assertTrue("questionfour" in browser.contents)
def testmyfavoritefolderView(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
event.notify(FavoriteEvent(self.answer1))
event.notify(FavoriteEvent(self.answer2))
event.notify(FavoriteEvent(self.answer3))
browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
import transaction
transaction.commit()
myfavoritefolder = portal.absolute_url() + '/@@myfavoritefolder'
browser.open(myfavoritefolder)
self.assertTrue("questionone" in browser.contents)
self.assertTrue("questiontwo" in browser.contents)
self.assertTrue("questionthree" in browser.contents)
self.assertTrue("answerone" in browser.contents)
self.assertTrue("answertwo" in browser.contents)
self.assertTrue("answerthree" in browser.contents)
self.assertTrue("test_user_1_" in browser.contents)
def test_controlpanel(self):
portal = self.layer['portal']
# Now as an admin user, go through the steps in the browser
browser = Browser(portal)
browser.handleErrors = False
browser.addHeader('Authorization', 'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,))
browser.open('http://nohost/plone/plone_control_panel')
settings_link = browser.getLink('Stripe Payment Processing')
settings_link.click()
self.assertEqual('http://nohost/plone/@@stripe-settings', browser.url)
# Set the values in the control panel
browser.getControl(name='form.widgets.mode:list').value = ["test",]
browser.getControl(name='form.widgets.live_secret_key').value = "1234567890"
browser.getControl(name='form.widgets.live_publishable_key').value = "9876543210"
browser.getControl(name='form.widgets.test_secret_key').value = "qwertyuiop"
browser.getControl(name='form.widgets.test_publishable_key').value = "poiuytrewq"
browser.getControl(name='form.buttons.save').click()
# Check that the settings were changed in the registry
settings = get_settings()
self.assertEqual(settings.mode, "test")
self.assertEqual(settings.live_secret_key, "1234567890")
self.assertEqual(settings.live_publishable_key, "9876543210")
self.assertEqual(settings.test_secret_key, "qwertyuiop")
self.assertEqual(settings.test_publishable_key, "poiuytrewq")
def test_controlpanel(self):
setRoles(self.portal, TEST_USER_ID, ('Manager', ))
transaction.commit()
from uniofleicester.jscontent.interfaces import IAllowedSectionsSchema
registry = getUtility(IRegistry)
settings = registry.forInterface(IAllowedSectionsSchema)
self.assertEqual(settings.section, [
'/',
])
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open("{}/login".format(self.portal.absolute_url()))
browser.getControl(name='__ac_name').value = TEST_USER_NAME
browser.getControl(name='__ac_password').value = TEST_USER_PASSWORD
browser.getControl(name='submit').click()
browser.open("{}/@@allowed-sections".format(
self.portal.absolute_url()))
browser.getControl(name='form.widgets.section').value = "/news\n/study"
browser.getControl(name='form.buttons.save').click()
self.assertEqual(settings.section, [u'/news', u'/study'])
def prepare_for_acquisition_tests(self):
"""create content and an alternate authenticated browser session
creates the following content structure:
|-- f1
| |-- test
|-- test
"""
# create a page at the root and one nested with the same id.
p1 = self.portal.invokeFactory(
type_name='Document', id='test', title='Test Page at Root')
folder_1 = self.portal['f1']
p2 = folder_1.invokeFactory(
type_name='Document', id='test', title='Test Page in Folder')
contained_test_page = folder_1[p2]
transaction.commit()
# create an alternate browser also logged in with manager
browser_2 = Browser(self.layer['app'])
browser_2.handleErrors = False
browser_2.addHeader(
'Authorization', 'Basic {0}:{1}'.format(TEST_USER_NAME, 'secret'))
# return the id of the root page, the nested page itself, and the
# alternate browser
return p1, contained_test_page, browser_2
def prepare_for_acquisition_tests(self):
"""create content and an alternate authenticated browser session
creates the following content structure:
|-- f1
| |-- test
|-- test
"""
# create a page at the root and one nested with the same id.
p1 = self.portal.invokeFactory(type_name='Document',
id='test',
title='Test Page at Root')
folder_1 = self.portal['f1']
p2 = folder_1.invokeFactory(type_name='Document',
id='test',
title='Test Page in Folder')
contained_test_page = folder_1[p2]
transaction.commit()
# create an alternate browser also logged in with manager
browser_2 = Browser(self.layer['app'])
browser_2.handleErrors = False
browser_2.addHeader('Authorization',
'Basic {0}:{1}'.format(TEST_USER_NAME, 'secret'))
# return the id of the root page, the nested page itself, and the
# alternate browser
return p1, contained_test_page, browser_2
def testGalleryFolder(self):
login(self.portal, TEST_USER_NAME)
setRoles(self.portal, TEST_USER_ID, ('Manager', ))
gallery = api.content.create(self.portal, "Gallery", "gallery",
"Gallery")
# Adding a page should fail
self.assertRaises(api.content.InvalidParameterError,
api.content.create, gallery, "Page", "page", "Page")
# Adding an image should pass
img = api.content.create(gallery,
"Image",
"img1",
"Image 1",
image=getData('image.jpg'))
# Commit so it is visible in the browser
transaction.commit()
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(gallery.absolute_url())
self.assertTrue('uol-gallery' in browser.contents)
self.assertTrue(img.absolute_url() in browser.contents)
self.assertTrue("photoSwipe" in 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_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)
def test_collection_templates(self):
data = getData('image.png')
# add an image that will be listed by the collection
self.portal.invokeFactory("Image",
"image",
title="Image example",
image=data)
# Search for images
query = [{
'i': 'Type',
'o': 'plone.app.querystring.operation.string.is',
'v': 'Image',
}]
# set the query and publish the collection
self.collection.setQuery(query)
commit()
logout()
# open a browser to see if our image is in the results
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open summary_view template
browser.open('%s/summary_view' % self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open folder_summary_view template
browser.open('%s/folder_summary_view' % self.collection.absolute_url())
self.assertTrue("Image example" in browser.contents)
# open thumbnail_view template
browser.open('%s/thumbnail_view' % self.collection.absolute_url())
self.assertTrue("Image example" 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())
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_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)
def testtopicView(self):
app = self.layer['app']
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ('Manager',))
browser = Browser(app)
browser.handleErrors = False
intids = getUtility(IIntIds)
portal['folder']['questionfolder'].invokeFactory('emc.kb.question', 'question4',
title='newquestion',
affiliatedtopics=[RelationValue(intids.getId(self.t1))],
)
# browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
browser.addHeader('Authorization', 'Basic %s:%s' % ('user3', 'secret',))
import transaction
transaction.commit()
browser.open(self.t1.absolute_url())
self.assertTrue("topicone" in browser.contents)
self.assertTrue("descriptionone" in browser.contents)
# self.assertTrue("newquestion" in browser.contents)
self.assertTrue("questionone" in browser.contents)
self.assertTrue("answerone" in browser.contents)
def test_sendmessage_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()
from emc.memberArea.content.outputbox import IOutputbox
obj = portal['work1']['folder1']['output1']
self.assertTrue(IOutputbox.providedBy(obj))
# import pdb
# pdb.set_trace()
#
# page = obj.absolute_url() + '/@@write_message'
# # import pdb
# # pdb.set_trace()
# browser.open(page)
# outstr = "send message to member"
# self.assertTrue(outstr in browser.contents)
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_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)
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 setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
browser = Browser(self.app)
browser.handleErrors = False
browser.raiseHttpErrors = False
self.browser = browser
def get_browser(self):
browser = Browser(self.layer["app"])
browser.handleErrors = False
browser.addHeader(
"Authorization",
"Basic {0}:{1}".format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
)
return browser
def test_userid_header_underscore_dash(self):
self.plugin.userid_header = "REMOTE_USER"
transaction.commit()
browser = Browser(self.app)
browser.handleErrors = False
browser.addHeader("REMOTE-USER", SITE_OWNER_NAME)
browser.open(self.portal_url + "/headerlogin")
self.assertEqual(browser.url, self.portal_url)
def test_anonymous_hotfixes_generation_is_not_allowed(self):
plonesite = self.layer["portal"]
app = self.layer["app"]
browser = Browser(app)
browser.handleErrors = False
# Try adding a vulnerability as an Anonymous user
with self.assertRaises(Unauthorized):
browser.open(plonesite.absolute_url() + "/++add++hotfix")
def setUp(doctest):
layer = doctest.globs['layer']
app = layer['app']
portal = layer['portal']
anon_browser = Browser(app)
admin_browser = Browser(app)
admin_browser.addHeader('Authorization', 'Basic admin:secret')
admin_browser.open(portal.absolute_url())
user_id = TEST_USER_NAME
user_password = TEST_USER_PASSWORD
def config_property(**kw):
for key, value in kw.items():
try:
registry = getUtility(IRegistry)
settings = registry.forInterface(
ILoginLockoutSettings, prefix="Products.LoginLockout")
setattr(settings, key, value)
continue
except ComponentLookupError:
pass
try:
p_tool = getToolByName(portal, 'portal_properties')
p_tool.loginlockout_properties.setProperty(key, value)
continue
except AttributeError:
raise
commit()
def get_loginlockout_settings():
registry = getUtility(IRegistry)
settings = registry.forInterface(ILoginLockoutSettings,
prefix="Products.LoginLockout")
return settings
doctest.globs.update(locals())
#
# def afterSetUp(self):
# # sm = getSiteManager(context=self.portal)
# # sm.unregisterUtility(provided=IMailHost)
# # sm.registerUtility(mailhost, provided=IMailHost)
# #
# # def setStatusCode(self, key, value):
# # from ZPublisher import HTTPResponse
# # HTTPResponse.status_codes[key.lower()] = value
#
anon_browser.handleErrors = False
portal.error_log._ignored_exceptions = ('Unauthorized', )
def raising(self, info):
import traceback
traceback.print_tb(info[2])
print info[1]
from Products.SiteErrorLog.SiteErrorLog import SiteErrorLog
SiteErrorLog.raising = raising
def test_add_to_portal_root_save(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),
)
# Simulate save action for creating a draft
storage = queryUtility(IDraftStorage)
draft = storage.createDraft(TEST_USER_ID, '++add++MyDocument')
target = createContent('MyDocument')
draft._draftAddFormTarget = target
transaction.commit()
browser.cookies.create(
DRAFT_NAME_KEY,
u'draft',
path='/plone',
)
# We can now fill in the required fields and save. The cookies should
# expire.
browser.getControl(
name='form.widgets.IDublinCore.title').value = u'New Document'
browser.getControl(name='form.buttons.save').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 browserLogin(self):
baseurl = self.portal.absolute_url()
browser = Browser(self.portal)
browser.handleErrors = False
browser.open(baseurl)
browser.getControl(name='__ac_name').value = TEST_USER_NAME
browser.getControl(name='__ac_password').value = TEST_USER_PASSWORD
browser.getControl(name='submit').click()
self.assertEqual(browser.url, baseurl, "Error, unable to authenticate")
return browser
def get_browser(layer, auth=True):
browser = Browser(layer["app"])
browser.handleErrors = False
if auth:
api.user.create(
username="******", password="******", email="*****@*****.**", roles=("Manager",)
)
transaction.commit()
browser.addHeader("Authorization", "Basic adm:secret")
return browser
def test_controlpanel(self):
browser = Browser(self.app)
browser.handleErrors = False
browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD, ),
)
browser.open("{}/@@caching-controlpanel".format(self.portal.absolute_url())) # noqa
browser.getControl(name='enabled:boolean').value = 'checked'
browser.getControl('Save').click()
def test_userid_header_underscores_http(self):
self.plugin.userid_header = "REMOTE_USER"
transaction.commit()
browser = Browser(self.app)
browser.handleErrors = False
# This will fail because it will really result in a
# header HTTP_HTTP_REMOTE_USER.
browser.addHeader("HTTP_REMOTE_USER", SITE_OWNER_NAME)
browser.open(self.portal_url + "/headerlogin")
# We are anonymous, so headerlogin redirects us to standard login.
self.assertEqual(browser.url, self.portal_url + "/login")
def getBrowser(self, loggedIn=True):
""" instantiate and return a testbrowser for convenience """
browser = Browser(self.portal)
browser.handleErrors = False
if loggedIn:
browser.open(self.portal.absolute_url())
browser.getControl('Login Name').value = TEST_USER_NAME
browser.getControl('Password').value = TEST_USER_PASSWORD
browser.getControl('Log in').click()
self.assertTrue('You are now logged in' in browser.contents)
return browser
def test_captcha_prevents_send(self):
browser = Browser(self.layer['app'])
browser.handleErrors = False
browser.open(self.portal.absolute_url())
browser.getControl('Your Name').value = 'Roman'
browser.getControl('Your Email').value = '*****@*****.**'
browser.getControl('Your Message').value = 'Good stuff'
browser.getControl('Captcha').value = 'ignored'
browser.getControl('Submit').click()
self.assertTrue('There were some errors' in browser.contents)
self.assertTrue('The code you entered was wrong' in browser.contents)
def test_view_cinemas_for_film(self):
app = self.layer['app']
portal = self.layer['portal']
browser = Browser(app)
browser.handleErrors = False
browser.open(portal['films']['film1'].absolute_url())
self.assertEqual(
browser.getLink('Cinema 1').url,
portal['cinemas']['cinema1'].absolute_url())
def get_browser(self, login=True):
from plone.testing.z2 import Browser
browser = Browser(self.layer['app'])
browser.handleErrors = False
if login:
browser.addHeader(
'Authorization',
'Basic %s:%s' % (self.testing.SITE_OWNER_NAME,
self.testing.SITE_OWNER_PASSWORD))
return browser
def test_restrictedTraverse(self):
portal = self.layer['portal']
app = self.layer['app']
browser = Browser(app)
browser.handleErrors = False
# The easiest way to look up a tile in Zope 2 is to use traversal:
traversed = portal.restrictedTraverse(
'@@plone.app.tiles.demo.transient/tile-1')
self.failUnless(isinstance(traversed, TransientTile))
self.assertEquals('plone.app.tiles.demo.transient', traversed.__name__)
self.assertEquals('tile-1', traversed.id)
def test_addsite_view(self):
import base64
browser = Browser(self.layer['app'])
browser.handleErrors = False
basic_auth = 'Basic {0}'.format(
base64.encodestring('{0}:{1}'.format(SITE_OWNER_NAME,
SITE_OWNER_PASSWORD)))
browser.addHeader('Authorization', basic_auth)
browser.open('{0}/@@plone-addsite?site_id=site'.format(
self.app.absolute_url()))
# site_id veio do parametro de query string
self.assertIn('"site"', browser.contents)
self.assertIn('Name of Ministry or', browser.contents)
