class Instance(object):
def __init__(self):
self.context = context
self.request = TestRequest()
self.request.setPrincipal(self)
title = 'principal'
def _getRequest(self, **kw):
environ = kw.pop('environ', {})
environ['HTTP_HOST'] = 'foo'
request = BrowserRequest(BytesIO(), environ=environ, **kw)
request._cookies = {'edit_languages': 'en,de'}
request._traversed_names = ['foo', 'bar']
return request
def test_update(self):
c = C()
request = TestRequest()
v = EV(c, request)
request.form[Update] = ''
request.form['field.foo'] = u'r foo'
request.form['field.bar'] = u'r bar'
request.form['field.getbaz'] = u'r baz'
request.form['field.a'] = u'c a'
message = v.update()
self.assertTrue(message.startswith('Updated '), message)
self.assertEqual(c.foo, u'r foo')
self.assertEqual(c.bar, u'r bar')
self.assertEqual(c.a , u'c a')
self.assertEqual(c.b , u'c b') # missing from form - unchanged
self.assertEqual(c.getbaz(), u'r baz')
# Verify that calling update multiple times has no effect
c.__dict__.clear()
self.assertEqual(v.update(), message)
self.assertEqual(c.foo, u'c foo')
self.assertEqual(c.bar, u'c bar')
self.assertEqual(c.a , u'c a')
self.assertEqual(c.b , u'c b')
self.assertEqual(c.getbaz(), u'c baz')
def test_double_validation(self):
""" If a field already has an error and it is validated again,
we cut the validation short and return the original error.
Here we test that we do not lose the original error in the
process. We do that by adding the fieldsets twice in the
request, which can happen if you have some whacky javascript
that tries to clone too many inputs.
"""
dummy = self.makeDummy()
request = TestRequest()
alsoProvides(request, IAttributeAnnotatable)
my_values = field_values.copy()
my_values['fixedpointfield2'] = 'an_error'
request.form.update(my_values)
request.form['fieldset'] = 'default'
request.form['fieldsets'] = ['default', 'default']
errors = {}
dummy.validate(errors=errors, REQUEST=request)
self.assertTrue(errors, errors)
# The validation error looks a bit weird because of the
# [[plone]] domain that is added by the translation testing
# machinery.
self.assertEqual(errors['fixedpointfield2'],
(u"[[plone][Validation failed(isDecimal): "
"'an_error' [[plone][is not a decimal number.]]]]"))
def test_applyUpdates_and_setPrefix(self):
registry = TestingRegistrationStack(a, b, c)
request = TestRequest()
view = ChangeRegistrations(registry, request)
view.setPrefix("Pigs")
# Make sure we don't apply updates unless asked to
request.form = {'Pigs.active': 'disable'}
view.applyUpdates()
data = [(info['active'], info['registration'])
for info in registry.info()]
self.assertEqual(data, [(True, a), (False, b), (False, c)])
# Now test disabling
request.form = {'submit_update': '', 'Pigs.active': 'disable'}
view.applyUpdates()
data = [(info['active'], info['registration'])
for info in registry.info()]
self.assertEqual(data, [(False, a), (False, b), (False, c)])
# Now test enabling c
request.form = {'submit_update': '', 'Pigs.active': 'c'}
view.applyUpdates()
data = [(info['active'], info['registration'])
for info in registry.info()]
self.assertEqual(data, [(True, c), (False, a), (False, b)])
def create_viewlet(self, viewlet, context=None, view=None, manager=None):
if context is None:
context = self.portal
request = TestRequest()
directlyProvides(request, IAttributeAnnotatable)
request.set = mock.Mock()
return viewlet(context, request, view, manager)
def test_retry_keeps_everything(self):
"""lowlevel test for retry (see #98440)"""
from zope.publisher.browser import TestRequest
from zope.publisher.skinnable import setDefaultSkin
from zope.publisher.interfaces import IDefaultSkin
from zope.publisher.interfaces.browser import IBrowserRequest
from zope.publisher.interfaces.browser import IBrowserSkinType
# create a retryable request
request = TestRequest()
self.assertTrue(request.supportsRetry())
# create a skin and register it as the default skin
class ISomeSkin(Interface):
pass
alsoProvides(ISomeSkin, IBrowserSkinType)
provideAdapter(ISomeSkin, (IBrowserRequest,), IDefaultSkin)
# set the default skin for the request
setDefaultSkin(request)
# create a retried request
retried = request.retry()
# the requests are not the same
self.assertTrue(request is not retried)
# the requests both provide the default skin
self.assertTrue(ISomeSkin.providedBy(request))
self.assertTrue(ISomeSkin.providedBy(retried))
def __call__(self, filename, title, description, content_type, data,
portal_type):
context = aq_inner(self.context)
error = ''
result = {}
result['success'] = None
newid = get_id_from_filename(filename, context)
chooser = INameChooser(context)
newid = chooser.chooseName(newid, context)
# consolidation because it's different upon Plone versions
if not title:
# try to split filenames because we don't want
# big titles without spaces
title = filename.rsplit('.', 1)[0]\
.replace('_', ' ')\
.replace('-', ' ')
if newid in context:
# only here for flashupload method since a check_id is done
# in standard uploader - see also XXX in quick_upload.py
raise NameError, 'Object id %s already exists' % newid
else:
upload_lock.acquire()
try:
transaction.begin()
try:
from zope.publisher.browser import TestRequest
request = TestRequest()
dataobj = FileObj(data)
dataobj.filename = filename
request.form['doc'] = dataobj
request.form['ajax'] = '1'
from fhnw.office2plone.browser.docx_importer import DocxImporter
docximport = DocxImporter(self.context, request)
docximport.docx_import()
except ImportError:
error = ''
except Unauthorized:
error = u'serverErrorNoPermission'
except ConflictError:
# rare with xhr upload / happens sometimes with flashupload
error = u'serverErrorZODBConflict'
except ValueError:
error = u'serverErrorDisallowedType'
except Exception, e:
error = u'serverError'
logger.exception(e)
if error:
if error == u'serverError':
logger.info(
"An error happens with setId from filename, "
"the file has been created with a bad id, "
"can't find %s", newid)
else:
pass
#@TODO : rollback if there has been an error
transaction.commit()
finally:
def testUnauthorized(self):
exception = Exception()
try:
raise exception
except:
pass
request = TestRequest()
request.setPrincipal(DummyPrincipal(23))
u = Unauthorized(exception, request)
u.issueChallenge()
# Make sure the response status was set
self.assertEqual(request.response.getStatus(), 403)
# check headers that work around squid "negative_ttl"
self.assertEqual(request.response.getHeader('Expires'),
'Mon, 26 Jul 1997 05:00:00 GMT')
self.assertEqual(request.response.getHeader('Pragma'),
'no-cache')
self.assertEqual(request.response.getHeader('Cache-Control'),
'no-store, no-cache, must-revalidate')
# Make sure the auth utility was called
self.failUnless(self.auth.request is request)
self.assertEqual(self.auth.principal_id, 23)
def testUnauthorized(self):
component.provideAdapter(DummyTemplate, name="default")
exception = Exception()
try:
raise exception
except:
pass
request = TestRequest()
request.setPrincipal(DummyPrincipal(23))
u = Unauthorized(exception, request)
res = u()
# Make sure that we rendered the expected template
self.assertEqual("You are not authorized", res)
# Make sure the response status was set
self.assertEqual(request.response.getStatus(), 403)
# check headers that work around squid "negative_ttl"
self.assertEqual(request.response.getHeader('Expires'),
'Mon, 26 Jul 1997 05:00:00 GMT')
self.assertEqual(request.response.getHeader('Pragma'),
'no-cache')
self.assertEqual(request.response.getHeader('Cache-Control'),
'no-store, no-cache, must-revalidate')
# Make sure the auth utility was called
self.failUnless(self.auth.request is request)
self.assertEqual(self.auth.principal_id, 23)
def test_do_GET_minimal(self):
from sqlalchemy.orm import object_session
from zope.publisher.browser import TestRequest
from euphorie.client.model import Risk
self.loginAsPortalOwner()
(account, survey, survey_session) = _setup_session(self.portal)
survey['1'].title = u'Module title.'
risk = survey['1']['2']
risk.title = u'Everything is under control.'
risk.problem_description = u'Not everything under control.'
risk.description = None
risk.evaluation_method = 'direct'
risk.image = None
request = TestRequest()
request.survey = survey
risk = object_session(survey_session).query(Risk).first()
view = self.View(risk, request)
response = view.do_GET()
self.assertEqual(
set(response),
set(['id', 'type', 'title', 'module-title',
'problem-description', 'show-not-applicable',
'evaluation-method', 'present', 'priority', 'comment']))
self.assertEqual(response['id'], 2)
self.assertEqual(response['type'], 'risk')
self.assertEqual(response['title'], u'Everything is under control.')
self.assertEqual(response['module-title'], u'Module title.')
self.assertEqual(
response['problem-description'],
u'Not everything under control.')
self.assertEqual(response['show-not-applicable'], False)
self.assertEqual(response['evaluation-method'], 'direct')
self.assertEqual(response['present'], None)
self.assertEqual(response['priority'], u'high')
def testGlobalInVirtualHost(self):
req = TestRequest()
req.setVirtualHostRoot(['x', 'y'])
r = Resource(req)
req._vh_root = support.site
r.__parent__ = support.site
r.__name__ = 'foo'
self.assertEqual(r(), 'http://127.0.0.1/x/y/@@/foo')
def testURL(self):
request = TestRequest()
request._vh_root = support.site
path = os.path.join(test_directory, 'testfiles')
files = DirectoryResourceFactory(path, checker, 'test_files')(request)
files.__parent__ = support.site
file = files['test.gif']
self.assertEquals(file(), 'http://127.0.0.1/@@/test_files/test.gif')
def lockingSetUp(test):
placelesssetup.setUp(test)
z3c.etree.testing.etreeSetup(test)
# create principal
participation = TestRequest(environ = {"REQUEST_METHOD": "PUT"})
participation.setPrincipal(Principal("michael"))
if queryInteraction() is not None:
queryInteraction().add(participation)
else:
newInteraction(participation)
events = test.globs["events"] = []
zope.event.subscribers.append(events.append)
gsm = zope.component.getGlobalSiteManager()
gsm.registerAdapter(DemoKeyReference,
(IDemo,),
zope.app.keyreference.interfaces.IKeyReference)
gsm.registerAdapter(PhysicallyLocatable, (Demo,))
gsm.registerAdapter(PhysicallyLocatable, (DemoFolder,))
gsm.registerAdapter(DemoKeyReference, (IDemoFolder,),
zope.app.keyreference.interfaces.IKeyReference)
gsm.registerAdapter(SiteManagerAdapter,
(zope.interface.Interface,), IComponentLookup)
gsm.registerAdapter(DemoAbsoluteURL,
(IDemo, zope.interface.Interface),
zope.traversing.browser.interfaces.IAbsoluteURL)
gsm.registerAdapter(DemoAbsoluteURL,
(IDemoFolder, zope.interface.Interface),
zope.traversing.browser.interfaces.IAbsoluteURL)
# register some IDAVWidgets so that we can render the activelock and
# supportedlock widgets.
gsm.registerAdapter(z3c.dav.widgets.ListDAVWidget,
(zope.schema.interfaces.IList,
z3c.dav.interfaces.IWebDAVRequest))
gsm.registerAdapter(z3c.dav.widgets.ObjectDAVWidget,
(zope.schema.interfaces.IObject,
z3c.dav.interfaces.IWebDAVRequest))
gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
(zope.schema.interfaces.IText,
z3c.dav.interfaces.IWebDAVRequest))
gsm.registerAdapter(z3c.dav.properties.OpaqueWidget,
(z3c.dav.properties.DeadField,
z3c.dav.interfaces.IWebDAVRequest))
gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
(zope.schema.interfaces.IURI,
z3c.dav.interfaces.IWebDAVRequest))
# Need connection to a database to manage locking
db = test.globs["db"] = ZODB.DB(ZODB.MappingStorage.MappingStorage())
test.globs["conn"] = db.open()
# expose these classes to the test
test.globs["Demo"] = Demo
test.globs["DemoFolder"] = DemoFolder
def test_hooks(self):
@implementer(IAdding)
class Adding(object):
pass
adding = Adding()
self._invoke_add()
(descriminator, callable, args, kw) = self._context.last_action
factory = AddViewFactory(*args)
request = TestRequest()
request.form.update(dict([
("field.%s" % k, v)
for (k, v) in dict(SampleData.__dict__).items()
]))
request.form[Update] = ''
view = getMultiAdapter((adding, request), name='addthis')
# Add hooks to V
l=[None]
def add(aself, ob):
l[0] = ob
self.assertEqual(
ob.__dict__,
{'args': ("bar", "baz"),
'kw': {'email': '*****@*****.**'},
'_foo': 'foo',
})
return ob
V.add = add
V.nextURL = lambda self: 'next'
try:
self.assertEqual(view.update(), '')
self.assertEqual(view.errors, ())
self.assertEqual(l[0].extra1, "extra1")
self.assertEqual(l[0].extra2, "extra2")
self.assertEqual(l[0].name, "foo")
self.assertEqual(l[0].address, "aa")
self.assertEqual(request.response.getHeader("Location"), "next")
# Verify that calling update again doesn't do anything.
l[0] = None
self.assertEqual(view.update(), '')
self.assertEqual(l[0], None)
finally:
# Uninstall hooks
del V.add
del V.nextURL
def testNull(self):
container = self.Container({'foo': 42})
request = TestRequest()
request.method = 'PUT'
traverser = self.Traverser(container, request)
null = traverser.publishTraverse(request, 'bar')
self.assertEqual(null.__class__, NullResource)
self.assertEqual(null.container, container)
self.assertEqual(null.name, 'bar')
def test_recipient_from_request(self):
request = TestRequest(mail=self.ascii)
request.form['recipient'] = '*****@*****.**'
view = getMultiAdapter((self.portal, request), name='mail-inbound')
self.assertEquals('*****@*****.**', view.recipient())
request = TestRequest(mail=self.resent)
request.form['recipient'] = '*****@*****.**'
view = getMultiAdapter((self.portal, request), name='mail-inbound')
self.assertEquals('*****@*****.**', view.recipient())
def test_allowable_content_types_ok(self):
dummy = self.makeDummy()
request = TestRequest()
request.form.update(field_values)
request.form['fieldset'] = 'default'
dummy.REQUEST = request
errors = {}
dummy.validate(REQUEST=request, errors=errors)
self.assertFalse(errors, errors)
def testGlobal(self):
req = TestRequest()
r = Resource(req)
req._vh_root = support.site
r.__parent__ = support.site
r.__name__ = 'foo'
self.assertEqual(r(), 'http://127.0.0.1/@@/foo')
r.__name__ = '++resource++foo'
self.assertEqual(r(), 'http://127.0.0.1/@@/foo')
def test_make_extra_principal(self):
class MockPrincipal(object):
id = 'foo'
request = TestRequest()
request.setPrincipal(MockPrincipal())
reporter = SentryAwareLoggingErrorReporting()
result = reporter.make_extra(request)
self.assertTrue('sentry.interfaces.User' in result)
self.assertEqual('foo', result['sentry.interfaces.User']['id'])
def testSelectedFacetValues(self):
request = TestRequest()
selected = SearchFacetsView(Dummy(), request).selected
info = lambda: [(i["title"], i["value"]) for i in selected()]
request.form["fq"] = 'foo:"xy"'
self.assertEqual(info(), [("foo", "Title of Xy")])
request.form["fq"] = ['foo:"x"', 'bar:"y"']
self.assertEqual(info(), [("foo", "Title of X"), ("bar", "Title of Y")])
request.form["fq"] = ['foo:"x"', 'bar:"y"', 'bah:"z"']
self.assertEqual(info(), [("foo", "Title of X"), ("bar", "Title of Y"), ("bah", "Title of Z")])
def test_allowable_content_types_fail(self):
dummy = self.makeDummy()
request = TestRequest()
request.form.update(field_values)
request.form.update({'imagefield_file': pdf_file})
request.form['fieldset'] = 'default'
dummy.REQUEST = request
errors = {}
dummy.validate(REQUEST=request, errors=errors)
self.assertTrue(errors, errors)
def test_raising_with_xmlrpc_request(self):
# Test ErrorReportingUtility.raising() with an XML-RPC request.
request = TestRequest()
directlyProvides(request, IXMLRPCRequest)
request.getPositionalArguments = lambda: (1, 2)
utility = ErrorReportingUtility()
del utility._oops_config.publishers[:]
try:
raise ArbitraryException('xyz\nabc')
except ArbitraryException:
report = utility.raising(sys.exc_info(), request)
self.assertEqual("(1, 2)", report['req_vars']['xmlrpc args'])
def test_validation_visible_fields(self):
""" we assume that every field is visible """
dummy = self.makeDummy()
request = TestRequest()
alsoProvides(request, IAttributeAnnotatable)
field_values['fixedpointfield2'] = 'an_error'
request.form.update(field_values)
request.form['fieldset'] = 'default'
errors = {}
dummy.validate(errors=errors, REQUEST=request)
self.assertTrue(errors, errors)
def test___call__(self, IAdapter):
from DateTime import DateTime
from Products.ATContentTypes.interfaces.event import IATEvent
request = TestRequest()
adapter = getMultiAdapter((self.portal, request), ISearchEventResults)
request.form = {'start': '2013-05-09'}
IAdapter().portal_path.return_value = 'PORTAL_PATH'
adapter(limit=2)
IAdapter().get_content_listing.assert_called_with(IATEvent,
end={'query': [DateTime('2013-05-09')], 'range': 'min'},
b_size=10, sort_on='start', SearchableText='',
start={'query': [None], 'range': 'max'}, sort_limit=2, b_start=0, path='PORTAL_PATH')
def test_browserAddTheme(self):
request = TestRequest()
setDefaultSkin(request)
view = getMultiAdapter((self.portal, request),
name='minaraad_config.html')
lastId = max([x[0] for x in view.themeManager.themes])
request.form['theme_name'] = 'blah'
view._addTheme()
self.failUnless(view.themeManager.themes[-1] == (lastId + 1, 'blah'))
def test_invalid_input(self):
import json
import StringIO
from zope.publisher.browser import TestRequest
request = TestRequest()
request.stdin = StringIO.StringIO('invalid json')
view = self.JsonView(None, request)
response = view()
self.assertEqual(
json.loads(response),
{'type': 'error',
'message': 'Invalid JSON input'})
def testSelectedFacetValues(self):
request = TestRequest()
selected = SearchFacetsView(Dummy(), request).selected
info = lambda: [(i['title'], i['value']) for i in selected()]
request.form['fq'] = 'foo:"xy"'
self.assertEqual(info(), [('foo', 'Title of Xy')])
request.form['fq'] = ['foo:"x"', 'bar:"y"']
self.assertEqual(info(),
[('foo', 'Title of X'), ('bar', 'Title of Y')])
request.form['fq'] = ['foo:"x"', 'bar:"y"', 'bah:"z"']
self.assertEqual(info(), [('foo', 'Title of X'), ('bar', 'Title of Y'),
('bah', 'Title of Z')])
def afterSetUp(self):
""" Set up
"""
from zope.publisher.browser import TestRequest
from eea.design.browser.frontpage import Frontpage
portal = self.portal
wf = portal.portal_workflow
# Create the 'spotlight' and 'multimedia' promotion categories:
self.setRoles(['Manager'])
portal.SITE.invokeFactory('Folder', id='quicklinks')
portal.SITE.quicklinks.invokeFactory(
'Folder', id='spotlight', title=u'Spotlight')
portal.SITE.quicklinks.invokeFactory(
'Folder', id='multimedia', title=u'Multimedia')
portal.SITE.reindexObject()
portal.SITE.quicklinks.reindexObject()
portal.SITE.quicklinks.spotlight.reindexObject()
portal.SITE.quicklinks.multimedia.reindexObject()
wf.doActionFor(portal.SITE, 'publish')
wf.doActionFor(portal.SITE.quicklinks, 'publish')
wf.doActionFor(portal.SITE.quicklinks.spotlight, 'publish')
wf.doActionFor(portal.SITE.quicklinks.multimedia, 'publish')
# Also make sure promotion categories with non-ascii titles work:
portal.SITE.quicklinks.invokeFactory(
'Folder', id='mat', title=u'Räksmörgås')
wf.doActionFor(portal.SITE.quicklinks.mat, 'publish')
# Set up the frontpage:
portal_properties = getToolByName(portal, 'portal_properties')
frontpage_properties = getattr(portal_properties,
'frontpage_properties')
frontpage_properties.manage_changeProperties(
promotionFolder='/plone/SITE/quicklinks')
request = TestRequest()
request.RESPONSE = DummyResponse()
frontpage = Frontpage(self.portal, request)
# Create a news item:
self.setRoles(['Manager'])
nid = portal.invokeFactory('News Item', id='test')
item = portal[nid]
item.setTitle(u'Foobar')
wf.doActionFor(item, 'publish')
self.item = item
self.frontpage = frontpage
self.request = request
def test_survey_info_filter_by_language(self):
from zope.publisher.browser import TestRequest
from euphorie.content.survey import Survey
from euphorie.client.sector import ClientSector
sector = ClientSector(id='ict', title=u'ICT')
sector['gaming'] = Survey(id='gaming', title=u'Gaming',
language='nl')
request = TestRequest()
request.form['language'] = 'en'
response = self.View(sector, request).do_GET()
self.assertEqual(len(response['surveys']), 0)
request.form['language'] = 'nl'
response = self.View(sector, request).do_GET()
self.assertEqual(len(response['surveys']), 1)
def makeRequest(self, cookie):
session = self.folder.pas.session
return TestRequest(**{session.cookie_name: cookie})
def test_show_paste(self):
view = ContentsView(self.folder, TestRequest())
self.assertFalse(view.show_paste())
def save_images(self, context):
"""Save images from ZODB to temp directory
"""
portal = getSite()
portal_url = portal.absolute_url()
if not portal_url.endswith('/'):
portal_url += '/'
portal_path = '/'.join(portal.getPhysicalPath())
reference_tool = getToolByName(portal, 'reference_catalog')
mtool = getToolByName(portal, 'portal_membership')
for filename, image in self.images:
size = None
# Traverse methods mess with unicode
if type(image) is unicode:
image = str(image)
path = image.replace(portal_url, '')
item = None
# using uid
if 'resolveuid' in image:
# uid is the traversed value coming after "resolveuid/"
resolveuidpath = image.split('/')
resolveuid_idx = resolveuidpath.index('resolveuid')
try:
uuid = resolveuidpath[resolveuid_idx + 1]
except IndexError:
logger.error("Failed to get image uid from %s", image)
continue
item = reference_tool.lookupObject(uuid)
if len(resolveuidpath) >= resolveuid_idx + 2:
size = resolveuidpath[resolveuid_idx + 2]
logger.debug("Get image from uid %s", uuid)
if not item:
# relative url
try:
item = context.restrictedTraverse(image)
logger.debug("Get image from context")
except Unauthorized:
logger.warning(
"Unauthorized to get image from context path %s", item)
except:
logger.debug("Failed to get image from context path %s",
image)
if not item:
# plone.app.imaging
if '@@images' in path and AnnotationStorage:
context_path, images_str, uid_filename = path.rsplit(
'/', 2)
image_context = portal.restrictedTraverse(context_path)
uid, ext = uid_filename.rsplit('.', 1)
storage = AnnotationStorage(image_context)
info = storage.get(uid)
if info is not None:
request = TestRequest()
scale_view = ImageScale(image_context, request, **info)
item = scale_view.__of__(image_context)
if not item:
# absolute url
image_path = '/'.join((portal_path, path))
try:
item = portal.restrictedTraverse(image_path)
logger.debug("Get image from portal")
except Unauthorized:
logger.warning("Unauthorized to get from context path %s",
image_path)
except:
logger.error("Failed to get image from portal path %s",
image_path)
continue
if not mtool.checkPermission('View', item):
logger.warning("Unauthorized to get image %s", item)
continue
if item and size:
try:
item = item.restrictedTraverse(size)
except Unauthorized:
logger.warning("Unauthorized to get size %s from image %s",
size, image)
except:
logger.error("Failed to get size %s from image %s", size,
image)
pass
# Eek, we should put an adapter for various image providers (overkill ?).
data = get_image_data(item)
if data:
_write_file(data, self.fsinfo, filename)
return
def test_get_ids(self):
request = TestRequest(form={'form.select_ids': ['DummyItem1',
'DummyItem3']})
view = ContentsView(self.folder, request)
self.assertEqual(view._get_ids(), ['DummyItem1', 'DummyItem3'])
def testNoContextInformation(self):
request = TestRequest()
view = getMultiAdapter((None, request), name='absolute_url')
self.assertEqual(str(view), 'http://127.0.0.1')
self.assertEqual(absoluteURL(None, request), 'http://127.0.0.1')
def test_interface(self):
request = TestRequest()
content = contained(TrivialContent(), Root(), name='a')
view = getMultiAdapter((content, request), name='absolute_url')
verifyObject(IAbsoluteURL, view)
def test_list_batch_items(self):
view = ContentsView(self.folder, TestRequest())
view._getNavigationVars = lambda: {}
self.assertEqual(view.listBatchItems(), ())
def test_up_info(self):
view = ContentsView(self.folder, TestRequest())
self.assertEqual({'url': u'', 'id': u'Root', 'icon': u''},
view.up_info())
def test_view(self):
view = ContentsView(self.folder, TestRequest())
self.assertTrue(IBrowserPublisher.providedBy(view))
def test_getNavigationURL(self):
url = 'http://example.com/folder_contents'
self._make_batch()
view = ContentsView(self.folder, TestRequest(ACTUAL_URL=url))
view._getNavigationVars = lambda: {}
self.assertTrue(view._getNavigationURL(25) == url + "?form.b_start=25")
def test_folder_not_has_local(self):
self._make_one()
view = FolderView(self.folder, TestRequest())
self.assertFalse(view.has_local())
def test_folder_has_local(self):
self._make_one('local_pt')
view = FolderView(self.folder, TestRequest())
self.assertTrue(view.has_local())
def testNotFound(self):
from zope.app.publisher.browser.resources import Resources
from zope.publisher.interfaces import NotFound
request = TestRequest()
view = Resources(None, request)
self.assertRaises(NotFound, view.publishTraverse, request, 'test')
def folderitems(self):
rc = getToolByName(self.context, REFERENCE_CATALOG)
wf = getToolByName(self.context, 'portal_workflow')
pr = getToolByName(self.context, 'portal_repository')
isVersionable = pr.isVersionable(aq_inner(self.context))
try:
review_history = wf.getInfoFor(self.context, 'review_history')
review_history = list(review_history)
review_history.reverse()
except WorkflowException:
review_history = []
items = []
for entry in review_history:
# this folderitems doesn't subclass from the bika_listing.py
# so we create items from scratch
review_state = entry.get('review_state')
state_title = wf.getTitleForStateOnType(review_state,
self.context.portal_type)
item = {
'obj': self.context,
'id': self.context.id,
'uid': self.context.UID(),
'title': self.context.title_or_id(),
'type_class': '',
'url': self.context.absolute_url(),
'relative_url': self.context.absolute_url(),
'view_url': self.context.absolute_url(),
'path': "/".join(self.context.getPhysicalPath()),
'replace': {},
'before': {},
'after': {},
'choices': {},
'class': {},
'state_class': '',
'allow_edit': [],
'required': [],
'Version':
isVersionable and self.context.get('version_id', '') or '0',
'Date': self.ulocalized_time(entry.get('time')),
'sortable_date': entry.get('time'),
'User': entry.get('actor'),
'Action': entry.get('action') and entry.get('action')
or 'Create',
'Description': "review state: %s" % state_title,
}
items.append(item)
if isVersionable:
request = TestRequest()
chv = ContentHistoryViewlet(self.context, request, None, None)
chv.navigation_root_url = chv.site_url = 'http://localhost:8080/bikas'
version_history = chv.revisionHistory()
else:
version_history = []
for entry in version_history:
# this folderitems doesn't subclass from the bika_listing.py
# so we create items from scratch
# disregard the first entry of version history, as it is
# represented by the first entry in review_history
if not entry.get('version_id'):
continue
item = {
'obj': self.context,
'id': self.context.id,
'uid': self.context.UID(),
'title': self.context.title_or_id(),
'type_class': '',
'url': self.context.absolute_url(),
'relative_url': self.context.absolute_url(),
'view_url': self.context.absolute_url(),
'path': "/".join(self.context.getPhysicalPath()),
'replace': {},
'before': {},
'after': {},
'choices': {},
'class': {},
'state_class': '',
'allow_edit': [],
'required': [],
'Version': entry.get('version_id'),
'Date': self.ulocalized_time(DateTime(entry.get('time'))),
'sortable_date': entry.get('time'),
'User': entry.get('actor').get('fullname'),
'Action': entry.get('action') and entry.get('action')
or 'Create',
'Description': entry.get('comments'),
}
items.append(item)
items = sorted(items, key=itemgetter('sortable_date'))
items.reverse()
return items
def testCalendarView(self):
view = getMultiAdapter((self.folder, TestRequest()), name='ics_view')
view.update()
self.assertEqual(len(view.events), 2)
self.assertEqual(sorted([e.Title for e in view.events]),
['Plone Conf 2007', 'Plone Conf 2008'])
def _get_request_interfaces(self):
request = TestRequest()
notify(BeforeTraverseEvent(self.portal, request))
iro = list(request.__provides__.__iro__)
return iro
def testVirtualHostingWithoutContextInformation(self):
request = TestRequest()
request._vh_root = contained(TrivialContent(), Root(), name='a')
view = getMultiAdapter((None, request), name='absolute_url')
self.assertEqual(str(view), 'http://127.0.0.1')
self.assertEqual(absoluteURL(None, request), 'http://127.0.0.1')
def test_Shimadzu_NexeraLCMS8050Import(self):
pc = getToolByName(self.portal, 'portal_catalog')
workflow = getToolByName(self.portal, 'portal_workflow')
arimport = self.addthing(self.client, 'ARImport')
arimport.unmarkCreationFlag()
arimport.setFilename("test1.csv")
arimport.setOriginalFile("""
Header, File name, Client name, Client ID, Contact, CC Names - Report, CC Emails - Report, CC Names - Invoice, CC Emails - Invoice, No of Samples, Client Order Number, Client Reference,,
Header Data, test1.csv, Happy Hills, HH, Rita Mohale, , , , , 10, HHPO-001, ,,
Batch Header, id, title, description, ClientBatchID, ClientBatchComment, BatchLabels, ReturnSampleToClient,,,
Batch Data, B15-0123, New Batch, Optional descr, CC 201506, Just a batch, , TRUE ,,,
Samples, ClientSampleID, SamplingDate,DateSampled,Sampler,SamplePoint,SampleMatrix,SampleType,ContainerType,ReportDryMatter,Priority,Total number of Analyses or Profiles,Price excl Tax,CAL1,,,,MicroBio,,
Analysis price,,,,,,,,,,,,,,
"Total Analyses or Profiles",,,,,,,,,,,,,9,,,
Total price excl Tax,,,,,,,,,,,,,,
"Sample 1", HHS14001, 3/9/2014, 3/9/2014,,Toilet, Liquids, Water, Cup, 0, Normal, 1, 0, 0,0,0,0,0,1
""")
# check that values are saved without errors
arimport.setErrors([])
arimport.save_header_data()
arimport.save_sample_data()
arimport.create_or_reference_batch()
errors = arimport.getErrors()
if errors:
self.fail("Unexpected errors while saving data: " + str(errors))
# check that batch was created and linked to arimport without errors
if not pc(portal_type='Batch'):
self.fail("Batch was not created!")
if not arimport.schema['Batch'].get(arimport):
self.fail("Batch was created, but not linked to ARImport.")
# the workflow scripts use response.write(); silence them
arimport.REQUEST.response.write = lambda x: x
# check that validation succeeds without any errors
workflow.doActionFor(arimport, 'validate')
state = workflow.getInfoFor(arimport, 'review_state')
if state != 'valid':
errors = arimport.getErrors()
self.fail('Validation failed! %s.Errors: %s' %
(arimport.id, errors))
# Import objects and verify that they exist
workflow.doActionFor(arimport, 'import')
state = workflow.getInfoFor(arimport, 'review_state')
if state != 'imported':
errors = arimport.getErrors()
self.fail('Importation failed! %s.Errors: %s' %
(arimport.id, errors))
bc = getToolByName(self.portal, 'bika_catalog')
ars = bc(portal_type='AnalysisRequest')
ar = ars[0]
api.content.transition(obj=ar.getObject(), transition='receive')
transaction.commit()
#Testing Import for Instrument
path = os.path.dirname(__file__)
filename = '%s/files/nexera.csv' % path
if not os.path.isfile(filename):
self.fail("File %s not found" % filename)
data = open(filename, 'r').read()
file = FileUpload(TestFile(cStringIO.StringIO(data)))
request = TestRequest()
request = TestRequest(form=dict(submitted=True,
artoapply='received',
override='nooverride',
file=file,
sample='requestid',
instrument=''))
context = self.portal
results = Import(context, request)
transaction.commit()
text = 'Import finished successfully: 1 ARs and 1 results updated'
if text not in results:
self.fail("AR Import failed")
browser = self.getBrowser(loggedIn=True)
browser.open(ar.getObject().absolute_url() + "/manage_results")
content = browser.contents
if '0.025' not in content:
self.fail("AR Result did not get updated")
def testBadObject(self):
request = TestRequest()
view = getMultiAdapter((42, request), name='absolute_url')
self.assertRaises(TypeError, view.__str__)
self.assertRaises(TypeError, absoluteURL, 42, request)
def test_validate_items(self):
"""Cannot validate forms without widgets"""
view = ContentsView(self.folder, TestRequest())
self.assertRaises(AttributeError,
view.validate_items, "", {'foo': 'bar'})
from zope.schema import Field, Int, accessors
from zope.schema.interfaces import IField, IInt
from zope.app.testing import ztapi
from zope.formlibwidget import Widget
from zope.formlibwidget.interfaces import IWidget, IInputWidget, IDisplayWidget
from zope.formlibwidget.interfaces import ConversionError, InputErrors, WidgetsError
from zope.formlibwidget.interfaces import IWidgetFactory
from zope.formlibwidget.utility import no_value, setUpWidget, setUpWidgets
from zope.formlibwidget.utility import setUpEditWidgets, setUpDisplayWidgets
from zope.formlibwidget.utility import getWidgetsData, viewHasInput
from zope.formlibwidget.utility import applyWidgetsChanges
from zope.formlibwidget.tests import utils
request = TestRequest()
class IFoo(IField):
pass
class Foo(Field):
implements(IFoo)
class IBar(IField):
pass
class Bar(Field):
implements(IBar)
class IBaz(IInt):
pass
def geteventobject(principal):
myevent = TestRequest()
myevent.setPrincipal(principal)
return myevent
def test_display_editform(self):
foo = RadioTest()
request = TestRequest()
# display edit view
html = Form(foo, request)()
# S3
self.assert_(patternExists('<select .* name="form.s3".*>', html))
self.assert_(
patternExists('<option selected="selected" value="">', html))
self.assert_(patternExists('<option value="Bob">', html))
self.assert_(patternExists('<option value="is">', html))
self.assert_(patternExists('<option value="Your">', html))
self.assert_(patternExists('<option value="Uncle">', html))
# S4
joined_body = "".join(html.split("\n"))
self.failIf(
patternExists('<select.*name="form.s4".*>.*<option.*value="".*>',
joined_body))
self.assert_(patternExists('<select .* name="form.s4".*>', html))
self.assert_(
patternExists('<option selected="selected" value="1">', html))
self.assert_(patternExists('<option value="2">', html))
self.assert_(patternExists('<option value="3">', html))
request = TestRequest()
request.form['form.s3'] = u'Bob'
request.form['form.s4'] = u'2'
request.form['form.actions.apply'] = u''
# display edit view
html = Form(foo, request)()
self.assert_(
patternExists('<option selected="selected" value="Bob">', html))
self.assert_(
patternExists('<option selected="selected" value="2">', html))
html = Form(foo, request)()
self.assert_(
patternExists('<option selected="selected" value="Bob">', html))
self.assert_(
patternExists('<option selected="selected" value="2">', html))
request = TestRequest()
request.form['form.s3'] = u''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_(
patternExists('<option selected="selected" value="">', html))
self.assert_(
patternExists('<option selected="selected" value="2">', html))
request = TestRequest()
html = Form(foo, request)()
self.assert_(
patternExists('<option selected="selected" value="">', html))
def setUp(self):
self.setUpContent()
self.request = TestRequest()
self.widget = self._WidgetFactory(self.field, self.field.value_type,
self.request)
ztapi.browserViewProviding(ITextLine, DisplayWidget, IDisplayWidget)
import zope.interface
import md5
from interfaces import IMainSnippetManager
from Products.ZenUI3.utils.javascript import JavaScriptSnippetManager,\
JavaScriptSnippet, SCRIPT_TAG_TEMPLATE
from Products.ZenUI3.browser.interfaces import IJavaScriptSrcViewlet,\
IJavaScriptBundleViewlet, IJavaScriptSrcManager
from Products.Five.viewlet.viewlet import ViewletBase
from Products.ZenUI3.navigation.manager import WeightOrderedViewletManager
from Products.ZenUtils.extdirect.zope.metaconfigure import allDirectRouters
from zope.publisher.browser import TestRequest
from zope.component import getAdapter
from Products.ZenModel.ZVersion import VERSION
from Products.Zuul.decorators import memoize
dummyRequest = TestRequest()
@memoize
def getPathModifiedTime(path):
"""
This method takes a js request path such as /++resources++zenui/zenoss/file.js and
returns the last time the file was modified.
"""
if "++resource++" in path:
identifier = path.split('/')[1].replace("++resource++", "")
filePath = path.replace("/++resource++" + identifier, "")
resource = getAdapter(dummyRequest, name=identifier)
fullPath = resource.context.path + filePath
if os.path.exists(fullPath):
return os.path.getmtime(fullPath)
def test_show_basic(self):
self._make_one()
view = ContentsView(self.folder, TestRequest())
view._getNavigationVars = lambda: {}
self.assertTrue(view.show_basic())
def testEmptyFacetFieldWithZeroCounts(self):
fields = dict(foo={'foo': 0, 'bar': 0})
results = Dummy(facet_counts=dict(facet_fields=fields))
view = SearchFacetsView(Dummy(), TestRequest())
view.kw = dict(results=results)
self.assertEqual(view.facets(), [])
def test_getFormValue_w_default(self):
field = Text(__name__='foo', title=u"Foo Title", default=u"def")
request = TestRequest()
widget = self._WidgetFactory(field, request)
self.assertEqual(widget._getFormValue(), u'def')
def test_getNavigationURL(self):
url = 'http://example.com/view'
self._make_batch()
view = FolderView(self.folder, TestRequest(ACTUAL_URL=url))
self.assertEqual(view._getNavigationURL(25), url + "?b_start:int=25")
def setUp(self):
self.request = TestRequest()
setRequest(self.request)
self.portal = self.layer['portal']
login(self.portal, TEST_USER_NAME)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
