def afterSetUp(self):
self.userId = 'fred'
self.password = '******'
self.portal.acl_users.userFolderAddUser(self.userId, self.password,
['Manager'], [])
self.browser = Browser()
self._log_in()
def getBrowser(self, loggedIn=True):
""" instantiate and return a testbrowser for convenience """
browser = Browser()
if loggedIn:
auth = u'Basic {0}'.format(self.getCredentials())
browser.addHeader('Authorization', auth)
return browser
def test_auth(self):
# Based on Testing.ZopeTestCase.testFunctional
basic_auth = '%s:%s' % (user_name, user_password)
self.folder.addDTMLDocument('secret_html', file='secret')
self.folder.secret_html.manage_permission(view, ['Owner'])
path = '/' + self.folder.absolute_url(1) + '/secret_html'
# Test direct publishing
response = self.publish(path + '/secret_html')
self.assertEqual(response.getStatus(), 401)
response = self.publish(path + '/secret_html', basic_auth)
self.assertEqual(response.getStatus(), 200)
self.assertEqual(response.getBody(), b'secret')
# Test browser
url = 'http://localhost' + path
browser = Browser()
browser.raiseHttpErrors = False
browser.open(url)
self.assertTrue(browser.headers['status'].startswith('401'))
browser.login(user_name, user_password)
browser.open(url)
self.assertTrue(browser.headers['status'].startswith('200'))
self.assertEqual(browser.contents, 'secret')
def getBrowser(self, loggedIn=True):
""" instantiate and return a testbrowser for convenience """
browser = Browser()
if loggedIn:
user = ptc.default_user
pwd = ptc.default_password
browser.addHeader('Authorization', 'Basic %s:%s' % (user, pwd))
return browser
def test_handle_errors_true_redirect(self):
self.folder._setObject('redirect', RedirectStub())
browser = Browser()
with self.assertRaises(HTTPError):
browser.open('http://localhost/test_folder_1_/redirect')
self.assertTrue(browser.headers['status'].startswith('404'))
self.assertEqual(browser.url, 'http://localhost/redirected')
def test_handle_errors_false_redirect(self):
self.folder._setObject('redirect', RedirectStub())
browser = Browser()
browser.handleErrors = False
with self.assertRaises(NotFound):
browser.open('http://localhost/test_folder_1_/redirect')
self.assertTrue(browser.contents is None)
def test_raise_http_errors_false_redirect(self):
self.folder._setObject('redirect', RedirectStub())
browser = Browser()
browser.raiseHttpErrors = False
browser.open('http://localhost/test_folder_1_/redirect')
self.assertTrue(browser.headers['status'].startswith('404'))
self.assertEqual(browser.url, 'http://localhost/redirected')
def test_handle_errors_false(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
browser.handleErrors = False
# Even errors which can be handled by Zope go to the client:
with self.assertRaises(NotFound):
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.contents is None)
def setUp(self):
super(TestPublishTraverse, self).setUp()
zcml.load_config("configure.zcml", Products.Five)
zcml.load_config('pages.zcml', package=Products.Five.browser.tests)
uf = self.app.acl_users
uf.userFolderAddUser('manager', 'manager_pass', ['Manager'], [])
manage_addSimpleContent(self.folder, 'testoid', 'x')
self.browser = Browser()
self.browser.login('manager', 'manager_pass')
def getBrowser(self, logged_in=False):
""" instantiate and return a testbrowser for convenience """
browser = Browser()
if logged_in:
# Add an authorization header using the given or default
# credentials """
browser.addHeader(
'Authorization', 'Basic %s:%s' %
(PloneTestCase.portal_owner, PloneTestCase.default_password))
return browser
def test_raise_http_errors_false(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
browser.raiseHttpErrors = False
browser.open('http://localhost/test_folder_1_/stub')
self.assertTrue(browser.headers['status'].startswith('500'))
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.headers['status'].startswith('404'))
def test_headers_camel_case(self):
# The Zope2 response mungs headers so they come out
# in camel case. We should do the same.
self.folder._setObject('stub', CookieStub())
browser = Browser()
browser.open('http://localhost/test_folder_1_/stub')
header_text = str(browser.headers)
self.assertTrue('Content-Length: ' in header_text)
self.assertTrue('Content-Type: ' in header_text)
def test_handle_errors_true(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
with self.assertRaises(HTTPError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertTrue(browser.headers['status'].startswith('500'))
with self.assertRaises(HTTPError):
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.headers['status'].startswith('404'))
def test_handle_errors_false(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
browser.handleErrors = False
with self.assertRaises(ValueError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertTrue(browser.contents is None)
with self.assertRaises(NotFound):
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.contents is None)
def afterSetUp(self):
super(TestCase, self).afterSetUp()
self.browser = Browser()
self.portal.acl_users._doAddUser('admin', 'secret', ['Manager'], [])
self.portal._original_MailHost = self.portal.MailHost
self.portal.MailHost = mailhost = MockMailHost('MailHost')
self.membership = self.portal.portal_membership
sm = getSiteManager(context=self.portal)
sm.unregisterUtility(provided=IMailHost)
sm.registerUtility(mailhost, provided=IMailHost)
def getBrowser(self, loggedIn=False, admin=False):
""" instantiate and return a testbrowser for convenience """
browser = Browser()
if loggedIn:
u = PloneTestCase.default_user
p = PloneTestCase.default_password
browser.open(self.portal.absolute_url() + "/login_form")
browser.getControl(name='__ac_name').value = u
browser.getControl(name='__ac_password').value = p
browser.getControl(name='submit').click()
return browser
def test_cookies(self):
# We want to make sure that our testbrowser correctly
# understands cookies.
self.folder._setObject('stub', CookieStub())
# Test direct publishing
response = self.publish('/test_folder_1_/stub')
self.assertEqual(response.getCookie('evil')['value'], 'cookie')
browser = Browser()
browser.open('http://localhost/test_folder_1_/stub')
self.assertEqual(browser.cookies.get('evil'), '"cookie"')
def afterSetUp(self):
super(JsonClientTestCase, self).afterSetUp()
register_layer(IPMR2JsonClientTestLayer, 'pmr2.jsonclient.tests')
request = TestRequest()
# Ensure that the most basic scope managers are being used.
cmf = factory(ConsumerManager)
tmf = factory(TokenManager)
smf = factory(MockScopeManager)
zope.component.provideAdapter(cmf, (
IAnnotatable,
IPMR2JsonClientTestLayer,
), IConsumerManager)
zope.component.provideAdapter(tmf, (
IAnnotatable,
IPMR2JsonClientTestLayer,
), ITokenManager)
zope.component.provideAdapter(smf, (
IAnnotatable,
IPMR2JsonClientTestLayer,
), IScopeManager)
# assuming none of these are overridden.
self.consumer = Consumer('test.example.com', 'consumer-secret',
u'PMR2 Test JSON Client', None)
cm = zope.component.getMultiAdapter((self.portal, request),
IConsumerManager)
cm.add(self.consumer)
token = Token('pmr2token', 'token-secret')
token.access = True
token.consumer_key = self.consumer.key
token.user = default_user
self.token = token
tm = zope.component.getMultiAdapter((self.portal, request),
ITokenManager)
tm.add(self.token)
# XXX especially this one.
sm = zope.component.getMultiAdapter((self.portal, request),
IScopeManager)
sm.permitted = '^.*$' # permit everything.
b = Browser()
portal_url = self.portal.absolute_url()
b.open(portal_url + '/login')
b.getControl(name='__ac_name').value = default_user
b.getControl(name='__ac_password').value = default_password
b.getControl(name='submit').click()
self.user_browser = b
def test_handle_errors_true(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
# An error which cannot be handled by Zope is propagated to the client:
with self.assertRaises(ValueError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertIsNone(browser.contents)
# Handled errors become an instance of `HTTPError`:
with self.assertRaises(HTTPError):
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.headers['status'].startswith('404'))
def test_raise_http_errors_false(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
browser.raiseHttpErrors = False
# Internal server errors are still raised:
with self.assertRaises(ValueError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertIsNone(browser.contents)
# But errors handled by Zope do not create an exception:
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.headers['status'].startswith('404'))
def setUp(self):
from Products.PageTemplates.ZopePageTemplate import \
manage_addPageTemplate
super().setUp()
Zope2.App.zcml.load_site(force=True)
uf = self.app.acl_users
uf.userFolderAddUser('manager', 'manager_pass', ['Manager'], [])
manage_addPageTemplate(self.app, 'page_template')
self.browser = Browser()
self.browser.login('manager', 'manager_pass')
self.browser.open('http://localhost/page_template/manage_main')
def test_handle_errors_false(self):
self.folder._setObject('stub', ExceptionStub())
browser = Browser()
browser.handleErrors = False
# Custom exceptions get through
with self.assertRaises(ValueError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertTrue(browser.contents is None)
# HTTPException subclasses are handled
with self.assertRaises(HTTPError):
browser.open('http://localhost/nothing-is-here')
self.assertTrue(browser.headers['status'].startswith('404'))
def setUp(self):
from Products.PythonScripts.PythonScript import manage_addPythonScript
super(PythonScriptBrowserTests, self).setUp()
Zope2.App.zcml.load_site(force=True)
uf = self.app.acl_users
uf.userFolderAddUser('manager', 'manager_pass', ['Manager'], [])
manage_addPythonScript(self.app, 'py_script')
self.browser = Browser()
self.browser.addHeader(
'Authorization',
'basic {}'.format(
codecs.encode( # noqa: P101
b'manager:manager_pass', 'base64').decode()))
self.browser.open('http://localhost/py_script/manage_main')
class TestCase(ptc.PloneTestCase):
browser = Browser()
def login_as_user(self, username, password):
self.browser.open('http://nohost/plone/logout')
self.browser.open('http://nohost/plone/login_form')
self.browser.getControl(name='__ac_name').value = username
self.browser.getControl(name='__ac_password').value = password
self.browser.getControl(name='submit').click()
def login_as_manager(self):
self.login_as_user(ptc.portal_owner, ptc.default_password)
def register_user(self, data):
self.browser.open('http://nohost/plone/logout')
self.browser.open('http://nohost/plone/')
self.browser.getLink('Register').click()
data['password_confirm'] = data['password']
for key, value in data.items():
try:
self.browser.getControl(name=key).value = value
except LookupError:
if key == 'password_confirm':
# In Plone 4, password confirm is called password_ctl
self.browser.getControl(
name='form.password_ctl').value = value
else:
# Plone 4, inputs are called 'form.xxx'
self.browser.getControl(name='form.%s' % key).value = value
try:
self.browser.getControl(name='form.button.Register').click()
except LookupError:
self.browser.getControl(name='form.actions.register').click()
class layer(PloneSite):
@classmethod
def setUp(cls):
fiveconfigure.debug_mode = True
ztc.installPackage(zest.cachetuning)
fiveconfigure.debug_mode = False
@classmethod
def tearDown(cls):
pass
def afterSetUp(self):
ptc.FunctionalTestCase.afterSetUp(self)
self.browser = Browser()
self.browser.handleErrors = False # Don't get HTTP 500 pages
self.login_portal = self.app.login_portal # logins go here
self.another_portal = self.app.another_portal # another portal
# The extra portals do not get a member setup from the base class.
# Add our user to the other portals to simulate an ldap environment.
for portal in (self.login_portal, self.another_portal):
portal.acl_users.userFolderAddUser(ptc.default_user,
ptc.default_password,
['Member'], [])
# Configure the login portal to allow logins from our sites.
self.login_portal.portal_properties.site_properties._updateProperty(
'allow_external_login_sites', [
self.portal.absolute_url(),
self.another_portal.absolute_url(),
])
# Configure our sites to use the login portal for logins and logouts
login_portal_url = self.login_portal.absolute_url()
for portal in (self.portal, self.another_portal):
site_properties = portal.portal_properties.site_properties
site_properties._updateProperty('external_login_url',
login_portal_url + '/login')
site_properties._updateProperty('external_logout_url',
login_portal_url + '/logout')
# Configure all sites to use a shared secret and set cookies per path
# (normally they would have different domains.)
for portal in (self.portal, self.login_portal, self.another_portal):
session = portal.acl_users.session
session._shared_secret = 'secret'
session.path = portal.absolute_url_path()
# Turn on self-registration
self.portal.manage_permission('Add portal member',
roles=['Manager', 'Anonymous'],
acquire=0)
def afterSetUp(self):
"""Add some extra content and do some setup.
"""
# We need to do this as Manager:
self.setRoles(['Manager'])
# Add some news items:
sample_text = "<p>Have I got news for <em>you</em>!</p>"
self.portal.news.invokeFactory('News Item',
'first',
title="First News",
text=sample_text)
self.portal.news.invokeFactory('News Item',
'second',
title="Second News",
text=sample_text)
# Set fullname and email address of test user:
member = self.portal.portal_membership.getAuthenticatedMember()
member.setMemberProperties({
'fullname': 'Test User',
'email': '*****@*****.**'
})
# Add extra members:
self.addMember('maurits', 'Maurits van Rees', '*****@*****.**')
self.addMember('reinout', 'Reinout van Rees', '*****@*****.**')
# Setup test browser:
try:
from Testing.testbrowser import Browser
Browser # pyflakes
except ImportError:
from Products.Five.testbrowser import Browser
self.browser = Browser()
self.browser.handleErrors = False
self.browser.addHeader('Accept-Language', 'en-US')
self.portal.error_log._ignored_exceptions = ()
# No more Manager:
self.setRoles([])
def test_handle_errors_false_HTTPExceptionHandler_in_app(self):
"""HTTPExceptionHandler does not handle errors if requested via WSGI.
This is needed when HTTPExceptionHandler is part of the WSGI pipeline.
"""
class WSGITestAppWithHTTPExceptionHandler(object):
"""Minimized testbrowser.WSGITestApp with HTTPExceptionHandler."""
def __call__(self, environ, start_response):
publish = HTTPExceptionHandler(publish_module)
wsgi_result = publish(environ, start_response)
return wsgi_result
self.folder._setObject('stub', ExceptionStub())
transaction.commit()
browser = Browser(wsgi_app=WSGITestAppWithHTTPExceptionHandler())
browser.handleErrors = False
with self.assertRaises(ValueError):
browser.open('http://localhost/test_folder_1_/stub')
self.assertIsNone(browser.contents)
def setUp(self):
self.portal = self.layer['portal']
self.browser = Browser()
