def test_thread_moved_missing_memberdata(self):
n = self._make_one()
n.thread_moved_text = u'salutation:%(salutation)s\nthreadtitle:%(threadtitle)s\nthreadurl:%(threadurl)s\nboardtitle:%(boardtitle)s\nsignature:%(mailsignature)s'
n.signature='signature'
n.salutations = {u'Herr':u'Sehr geehrter Herr %(firstname)s %(lastname)s', u'Frau':u'Sehr geehrte Frau %(firstname)s %(lastname)s'}
# if a user posts more than one comment, he still should get notified only once.
comment = CommentMock(id='testcomment2',
title='Re: test',
conversation=self.app.testforum.testthread,
text='Awesome!',
creator='123456')
self.app.testforum.testthread.comments.append(comment)
self.app.testforum.testthread._setObject(comment.id, comment)
mh = queryUtility(IMailHost)
mh.emails = []
mtool = queryUtility(IMembershipTool)
mtool.members['654321'] = None
n.thread_moved(self.app.testforum.testthread)
got = len(mh.emails)
self.failUnless(got==1, 'notifier should have sent 1 email, got %s instead' % got)
mail = mh.emails[0]
got = {}
got.update([tuple(kv.split(':', 1)) for kv in mail[0][0].as_string().split('\n\n')[1].split('\n')])
self.failUnless(got['threadtitle']=='test thread', 'unexpected thread title, got "%s"' % got['threadtitle'])
self.failUnless(got['threadurl']=='http://nohost/testforum/testthread', 'unexpected thread url, got "%s"' % got['threadurl'])
self.failUnless(got['boardtitle']=='test forum', 'unexpected board title, got "%s"' % got['boardtitle'])
self.failUnless(got['signature']=='signature', 'unexpected signature')
self.failUnless(got['salutation']=='Sehr geehrter Herr Max Mustermann', 'unexpected salutation, got "%s"' % got['salutation'])
def unmarkTargetOnRemove(alias, event):
"""When the alias is created,
"""
target = aq_inner(alias._target)
if target is not None and IHasAlias.providedBy(target):
intids = queryUtility(IIntIds)
catalog = queryUtility(ICatalog)
if intids is not None and catalog is not None:
try:
to_id = intids.getId(target)
except KeyError:
logger.error("Alias target %s does not have an intid" % target)
return
alias_base = aq_base(alias)
for rel in catalog.findRelations({
'to_id': to_id,
'from_interfaces_flattened': IAlias,
'from_attribute': '_aliasTarget',
}):
# abort if there is another alias
if alias_base is not rel.from_object:
return
noLongerProvides(target, IHasAlias)
def _verifyImport(self, obj):
util = queryUtility(IDummyInterface, name=u'foo')
self.failUnless(IDummyInterface.providedBy(util))
self.failUnless(util.verify())
util = queryUtility(IDummyInterface)
self.failUnless(IDummyInterface.providedBy(util))
self.failUnless(util.verify())
util = queryUtility(IDummyInterface, name='dummy tool name')
self.failUnless(IDummyInterface.providedBy(util))
self.failUnless(util.verify())
self.assertEqual(util.meta_type, 'dummy tool')
# make sure we can get the tool by normal means
tool = getattr(self.app, 'dummy_tool')
self.assertEqual(tool.meta_type, 'dummy tool')
self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
util = queryUtility(IDummyInterface, name='dummy tool name2')
self.failUnless(IDummyInterface.providedBy(util))
self.failUnless(util.verify())
self.assertEqual(util.meta_type, 'dummy tool2')
# make sure we can get the tool by normal means
tool = getattr(self.folder, 'dummy_tool2')
self.assertEqual(tool.meta_type, 'dummy tool2')
self.assertEquals(repr(aq_base(util)), repr(aq_base(tool)))
def test_unregister_behavior(self):
# Test taxonomy registration
taxonomy = queryUtility(ITaxonomy, name='collective.taxonomy.test')
self.assertIsNotNone(taxonomy)
# Unregister behavior
taxonomy.unregisterBehavior()
# Test behavior registration
behavior = queryUtility(IBehavior, name=taxonomy.getGeneratedName())
self.assertIsNone(behavior)
# Test index creation
pc = api.portal.get_tool('portal_catalog')
self.assertNotIn('taxonomy_test', pc.indexes())
# Test indexer registration
sm = getSiteManager()
indexer = sm._adapter_registrations.get(
((IDexterityContent, IZCatalog),
IIndexer, 'taxonomy_test'),
None)
self.assertIsNone(indexer)
# Test querystring configuration
registry = queryUtility(IRegistry)
self.assertIsNotNone(registry)
prefix = 'plone.app.querystring.field.taxonomy_test'
self.assertRaises(
KeyError, registry.forInterface, IQueryField, prefix=prefix) # noqa
def register(fti):
"""Helper method to:
- register an FTI as a local utility
- register a local factory utility
- register an add view
"""
fti = aq_base(fti) # remove acquisition wrapper
site = getUtility(ISiteRoot)
site_manager = getSiteManager(site)
portal_type = fti.getId()
fti_utility = queryUtility(IDexterityFTI, name=portal_type)
if fti_utility is None:
site_manager.registerUtility(
fti,
IDexterityFTI,
portal_type,
info='plone.dexterity.dynamic'
)
factory_utility = queryUtility(IFactory, name=fti.factory)
if factory_utility is None:
site_manager.registerUtility(
DexterityFactory(portal_type),
IFactory,
fti.factory,
info='plone.dexterity.dynamic'
)
def __call__(self):
colorsDict = self.calendar.queryColors
criterias = interfaces.IListBaseQueryCriteria(self.context)()
css = ''
if not colorsDict:
return css
for fieldid, selectedItems in [(a['i'], a.get('v')) for a in criterias]:
if not colorsDict.has_key(fieldid):
continue
for i in range(len(selectedItems)):
cValName = str(component.queryUtility(IURLNormalizer).normalize(safe_unicode(selectedItems[i])))
color = None
for k, v in colorsDict.get(fieldid, {}).items():
k = safe_unicode(k)
if k == cValName or str(component.queryUtility(IURLNormalizer).normalize(k)) == cValName:
color = v
break
if color:
css += 'label.%scolorIndex-%s {\n' % (fieldid, str(i))
css += ' color: %s;\n' % (str(color))
css += '}\n\n'
return css
def __init__(self, taskName, configId, scheduleIntervalSeconds=60, taskConfig=None):
"""
@param deviceId: the Zenoss deviceId to watch
@type deviceId: string
@param taskName: the unique identifier for this task
@type taskName: string
@param scheduleIntervalSeconds: the interval at which this task will be
collected
@type scheduleIntervalSeconds: int
@param taskConfig: the configuration for this task
"""
super(NmapPingTask, self).__init__(taskName, configId, scheduleIntervalSeconds, taskConfig=None)
# Needed for interface
self.name = taskName
self.configId = configId
self.state = TaskStates.STATE_IDLE
self.interval = scheduleIntervalSeconds
if taskConfig is None:
raise TypeError("taskConfig cannot be None")
self._preferences = taskConfig
self._daemon = component.getUtility(ZenCollector.interfaces.ICollector)
self._dataService = component.queryUtility(ZenCollector.interfaces.IDataService)
self._eventService = component.queryUtility(ZenCollector.interfaces.IEventService)
self._pings = 0
self._nmapPresent = False # assume nmap is not present at startup
self._nmapIsSuid = False # assume nmap is not SUID at startup
self._cycleIntervalReasonable = True # assume interval is fine at startup
self.collectorName = self._daemon._prefs.collectorName
# maps task name to ping down count and time of last ping down
self._down_counts = defaultdict(lambda: (0, None))
def render(self):
# Test that our installation was successful
pau = queryUtility(IAuthentication)
if pau is None or type(pau) is not PluggableAuthenticatorPlugin:
if pau is not None:
st = "PAU not installed correctly: %s" % pau
utilities = getUtilitiesFor(IAuthentication)
st += "\n Available utilities are: %s" % [u for u in utilities]
return st
else:
return "PAU Utility not found"
st = ('Success: Credentials plugins= %s; Authenticator plugins= %s' %
(pau.credentialsPlugins, pau.authenticatorPlugins))
roleMgr = IPrincipalRoleManager(self.context)
p = roleMgr.getPrincipalsForRole('gfn.Administrator')
st += "\n Administrators: %s" %p
for ut in pau.credentialsPlugins:
if queryUtility(ICredentialsPlugin, name=ut) is None:
st += '\n Could not find credentials plugin for %s' % ut
for ut in pau.authenticatorPlugins:
if queryUtility(IAuthenticatorPlugin, name=ut) is None:
st += '\n Could not find authenticator plugin for %s' % ut
return st
def __init__(self, fti=None):
if not fti:
return
sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_connection, default=None)
if sql_connection:
self.connection_name = sql_connection.name
else:
sql_connection = queryUtility(ISQLBaseConnectionUtility, name=fti.sql_table, default=None)
if sql_connection:
self.connection_name = sql_connection.name
else:
processor = SQLBaseConnectionUtility(fti)
connection_name = processor.name
LOG.info('Base connection utility registered as '+connection_name)
gsm = getGlobalSiteManager()
gsm.registerUtility(processor, ISQLBaseConnectionUtility, name=connection_name)
self.connection_name = connection_name
self.sql_table = fti.sql_table
self.factory = fti.factory
self.sql_id_column = getattr(fti, 'sql_id_column', None) and getattr(fti, 'sql_id_column', None) or 'id'
fieldnames = {}
for field_name, field in schema.getFieldsInOrder( fti.lookupSchema() ):
if getattr(field, 'sql_column', None):
sql_column = getattr(field, 'sql_column', None)
fieldnames[field_name] = sql_column
for line in getattr(fti, 'sql_fields_columns', []):
fieldnames[line.split(':')[0]] = line.split(':')[1]
self.fieldnames = fieldnames
def get_plone_members(self):
""" return filtered list of plone members as DisplayList
"""
global fmp_tool
if fmp_tool and queryUtility(IFastmemberpropertiesTool, 'fastmemberproperties_tool'):
log.debug("Use fastmemberpropertiestool to get memberproperties!")
fmp_tool = queryUtility(IFastmemberpropertiesTool, 'fastmemberproperties_tool')
member_properties = fmp_tool.get_all_memberproperties()
else:
log.info("We use plone API to get memberproperties, this is very \
slow on many members, please install inqbus.plone.fastmemberproperties to make it fast!")
acl_userfolder = getToolByName(self, 'acl_users')
member_objs = acl_userfolder.getUsers()
member_properties = {}
for member in member_objs:
probdict = {}
probdict['id'] = member.getUserId()
probdict['email'] = member.getProperty('email')
probdict['fullname'] = safe_unicode(member.getProperty('fullname'))
member_properties[probdict['id']] = probdict
if not member_properties:
return []
try:
results = atapi.DisplayList([(id, property['fullname'] + ' - ' + property['email'])
for id, property in member_properties.items()
if config.EMAIL_RE.findall(property['email'])])
except TypeError, e:
log.error(":get_plone_members: error in member_properties %s/ \
properties:'%s'" % (e, member_properties.items()))
def test_enabled_uninstalled(self):
dsb = DummyStorageBackend()
getSiteManager().registerUtility(
dsb, IStorageBackend, name='dummy_storage')
utilities = queryUtility(IUtilityRegistry, 'repodono.storage.backends')
utilities.enable('dummy_storage')
vocab = queryUtility(
IVocabularyFactory, name='repodono.storage.backends')(None)
self.assertEqual(vocab.getTermByToken(
'dummy_storage').token, 'dummy_storage')
getSiteManager().unregisterUtility(
dsb, IStorageBackend, name='dummy_storage')
vocab = queryUtility(
IVocabularyFactory, name='repodono.storage.backends')(None)
self.assertEqual(list(vocab), [])
# registry should be untouched at this point
registry = queryUtility(IRegistry)
self.assertEqual(
registry['repodono.storage.backends'], [u'dummy_storage'])
# shouldn't break anything.
utilities.disable('unrelated')
self.assertEqual(list(vocab), [])
# The bad value is no longer stored.
self.assertEqual(registry['repodono.storage.backends'], [])
def setupDefaultImages(site):
""" Move images from valentine-imagescales
"""
if ('valentine-imagescales' not in site.objectIds() or
IDepictionTool.providedBy(site['valentine-imagescales'])):
return setupGenericImage(site)
valentine = site['valentine-imagescales']
tool = queryUtility(IDepictionTool)
for image in valentine.objectIds():
if image not in tool.objectIds():
cb = valentine.manage_cutObjects(image)
tool.manage_pasteObjects(cb)
oldUrl = "/".join(valentine.getPhysicalPath())
site.manage_delObjects(['valentine-imagescales'])
# Add alias
storage = queryUtility(IRedirectionStorage)
storage.add(oldUrl, '/'.join(tool.getPhysicalPath()))
# Setup generic image
setupGenericImage(site)
def normalize(self, text, locale=None, max_length=MAX_LENGTH):
"""
Returns a normalized text. text has to be a unicode string and locale
should be a normal locale, for example: 'pt-BR', 'sr@Latn' or 'de'
"""
if locale is not None:
# Try to get a normalizer for the locale
util = queryUtility(IIDNormalizer, name=locale)
parts = LOCALE_SPLIT_REGEX.split(locale)
if util is None and len(parts) > 1:
# Try to get a normalizer for the base language if we asked
# for one for a language/country combination and found none
util = queryUtility(IIDNormalizer, name=parts[0])
# be defensive: if queryUtility() returns an instance of the same
# normalizer class as this one, we'll loop forever until
# "RuntimeError: maximum recursion depth exceeded" (ticket #11630)
if util is not None and util.__class__ is not self.__class__:
text = util.normalize(text, locale=locale)
text = baseNormalize(text)
# lowercase text
text = text.lower()
text = IGNORE_REGEX.sub('', text)
text = NON_WORD_REGEX.sub('-', text)
text = MULTIPLE_DASHES_REGEX.sub('-', text)
text = EXTRA_DASHES_REGEX.sub('', text)
return cropName(text, maxLength=max_length)
def publishTraverse(self, request, name):
if not self.fti_id:
return super(SQLDexterityPublishTraverse, self).publishTraverse(request, name)
connection = queryUtility(ISQLConnectionsUtility, name=self.fti_id, default=None)
if connection == None and self.portal_type:
fti = queryUtility(IDexterityFTI, name=self.fti_id, default=None)
if not fti:
return None
updateConnectionsForFti(self.fti)
connection = getUtility(ISQLConnectionsUtility, name=self.fti_id)
name = name.split('/')[0]
name = name.split('++')[0]
name = name.split('@@')[0]
sql_id_column = self.fti.sql_id_column
factory_utility = queryUtility(IFactory, name=self.fti.factory)
catalog = getToolByName(getSite(), 'portal_catalog')
results = catalog.unrestrictedSearchResults(portal_type=self.fti_id, id=name)
if results:
sql_id = results[0].sql_id
else:
sql_id = name
try:
sql_items = connection.query(id=sql_id)
except:
sql_items = []
if sql_items:
sql_item = sql_items[0]
sql_item_id = getattr(sql_item, sql_id_column, False)
item = factory_utility(sql_id=sql_item_id)
item.sql_virtual = True
return item.__of__(self.context)
return super(SQLDexterityPublishTraverse, self).publishTraverse(request, name)
def setupGenericImage(site):
""" Add generic image within portal_depiction if it doesn't exists
"""
tool = queryUtility(IDepictionTool, context=site)
tool = tool.__of__(site)
if 'generic' in tool.objectIds():
return
img = site.restrictedTraverse(
'++resource++eea.depiction.images/generic.jpg')
data = img.GET()
# needed for tests
storage = queryUtility(IStorage, name="__builtin__.str")
if storage is None:
from plone.namedfile.storages import StringStorable
provideUtility(StringStorable(), IStorage, name="__builtin__.str")
image = NamedBlobImage(data=data, contentType="image/jpeg",
filename=u"generic.jpg")
id = tool.invokeFactory('Image', id='generic', title='Generic')
obj = tool._getOb(id)
if IBaseObject.providedBy(obj):
obj.edit(image=image)
else:
obj.image = image
def onExternalChanged(obj, evt):
""" Handle external URL
"""
if not evt.external:
return
request = getattr(obj, 'REQUEST', None)
if not request:
return
mutator = queryAdapter(obj, IVisualizationConfig)
if not mutator:
return
new_json = {'items': [], 'properties': {}}
new_json['properties'].update(mutator.json.get('properties', {}))
data = queryUtility(IExternalData)
if not data:
return
datafile = StringIO(data(evt.external))
converter = queryUtility(ITable2JsonConverter)
try:
columns, data = converter(datafile)
except Exception, err:
logger.exception(err)
return
def reindex(self, batch=1000, skip=0):
""" find all contentish objects (meaning all objects derived from one
of the catalog mixin classes) and (re)indexes them """
requestFactory = queryUtility(IRequestFactory)
indexProcessor = queryUtility(IZeroCMSIndexQueueProcessor, name="zerocms")
zodb_conn = self.context._p_jar
log = self.mklog()
log('reindexing documents to ZeroCMS...\n')
if skip:
log('skipping indexing of %d object(s)...\n' % skip)
real = timer() # real time
lap = timer() # real lap time (for intermediate commits)
cpu = timer(clock) # cpu time
processed = 0
updates = {} # list to hold data to be updated
count = 0
for path, obj in findObjects(self.context):
if indexable(obj):
if getOwnIndexMethod(obj, 'indexObject') is not None:
log('skipping indexing of %r via private method.\n' % obj)
continue
count += 1
if count <= skip:
continue
indexProcessor.index(obj)
processed += 1
zodb_conn.cacheGC();
log('All documents exported to ZeroCMS.\n')
msg = 'processed %d items in %s (%s cpu time).'
msg = msg % (processed, real.next(), cpu.next())
log(msg)
logger.info(msg)
def __call__(self, **kwargs):
if self.request:
kwargs.update(self.request.form)
url = kwargs.get('url', '')
if not url:
logger.exception('Invalid URL: %s', url)
return ""
reader = kwargs.get('reader', '')
reader = queryUtility(IBabelReader, name=reader)
if not reader:
logger.exception('Unknown babel reader: %s', reader)
return ""
write = kwargs.get('writer', '')
writer = queryUtility(IBabelWriter, name=write)
if not writer:
logger.exception('Unknown babel writer: %s', writer)
return ""
try:
items = reader(url)
except Exception, err:
logger.exception(err)
return ""
def _unauthenticatedPrincipal():
group = component.queryUtility(interfaces.IUnauthenticatedGroup)
if group is not None:
_unauthenticatedGroup(group.id)
group = component.queryUtility(interfaces.IEveryoneGroup)
if group is not None:
_everybodyGroup(group.id)
def _translate(msgid, domain=None, mapping=None, context=None,
target_language=None, default=None):
if isinstance(msgid, (MessageID, Message)):
domain = msgid.domain
default = msgid.default
mapping = msgid.mapping
if default is None:
default = msgid
if domain:
util = queryUtility(ITranslationDomain, domain)
if util is None:
util = queryUtility(IFallbackTranslationDomainFactory)
if util is not None:
util = util(domain)
else:
util = queryUtility(IFallbackTranslationDomainFactory)
if util is not None:
util = util()
if util is None:
return interpolate(default, mapping)
return util.translate(msgid, mapping, context, target_language, default)
def getPageSiteLayout(context):
"""Get the path to the site layout for a page. This is generally only
appropriate for the view of this page. For a generic template or view, use
getDefaultSiteLayout(context) instead.
"""
layoutAware = ILayoutAware(context, None)
if layoutAware is not None:
if getattr(layoutAware, 'pageSiteLayout', None):
return layoutAware.pageSiteLayout
# Note: the sectionSiteLayout on context is for pages *under* context, not
# necessarily context itself
parent = aq_parent(aq_inner(context))
while parent is not None:
layout = ILayoutAware(parent, None)
if layout is not None:
if getattr(layout, 'sectionSiteLayout', None):
return layout.sectionSiteLayout
parent = aq_parent(aq_inner(parent))
fti = queryUtility(IDexterityFTI, name=context.portal_type)
if fti is not None and IPageFTI.providedBy(fti):
if fti.default_site_layout:
return fti.default_site_layout
registry = queryUtility(IRegistry)
if registry is None:
return None
return registry.get(DEFAULT_SITE_LAYOUT_REGISTRY_KEY)
def getObject(self, REQUEST=None):
path = self.getPath().split('/')
if not path:
return None
parent = aq_parent(self)
if (aq_get(parent, 'REQUEST', None) is None
and _GLOBALREQUEST_INSTALLED and _REQUESTCONTAINER_EXISTS):
request = getRequest()
if request is not None:
# path should be absolute, starting at the physical root
parent = self.getPhysicalRoot()
request_container = RequestContainer(REQUEST=request)
parent = aq_base(parent).__of__(request_container)
if len(path) > 1:
try:
parent = parent.unrestrictedTraverse(path[:-1])
except:
if path[:-2] == 'data-'+self.portal_type:
parent = queryMultiAdapter((None, ICollectiveBehaviorSQLLayer), IBrowserView, name='data-'+name, default=None)
try:
return parent.restrictedTraverse(path[-1])
except:
connection = queryUtility(ISQLConnectionsUtility, name=self.portal_type, default=None)
if connection == None and self.portal_type:
fti = queryUtility(IDexterityFTI, name=self.portal_type, default=None)
if not fti:
return None
updateConnectionsForFti(fti)
connection = queryUtility(ISQLConnectionsUtility, name=self.portal_type, default=None)
return connection.getVirtualItem(self.sql_id, context=parent)
def updateRelations(obj, event):
"""Re-register relations, after they have been changed.
"""
catalog = component.queryUtility(ICatalog)
intids = component.queryUtility(IIntIds)
if catalog is None or intids is None:
return
# check that the object has an intid, otherwise there's nothing to be done
try:
obj_id = intids.getId(obj)
except KeyError:
# The object has not been added to the ZODB yet
return
# remove previous relations coming from id (now have been overwritten)
# have to activate query here with list() before unindexing them so we don't
# get errors involving buckets changing size
rels = list(catalog.findRelations({'from_id': obj_id}))
for rel in rels:
catalog.unindex(rel)
# add new relations
addRelations(obj, event)
def setupVarious(context):
""" Custom setup """
if context.readDataFile('scoreboard.visualization.txt') is None:
return
ds = queryUtility(IDavizSettings)
if not ds.disabled('daviz.properties', 'ScoreboardVisualization'):
logger.info('Disabling Daviz Properties for ScoreboardVisualization')
ds.settings.setdefault('forbidden.daviz.properties', [])
ds.settings['forbidden.daviz.properties'].append(
'ScoreboardVisualization')
ptool = queryUtility(IPropertiesTool)
if not getattr(ptool, 'scoreboard_properties', None):
ptool.manage_addPropertySheet(
'scoreboard_properties', 'Scoreboard Properties')
stool = getattr(ptool, 'scoreboard_properties', None)
eu = stool.getProperty('EU', None)
if not eu:
default = json.dumps(EU, indent=2)
stool.manage_addProperty('EU', default, 'text')
whitelist = stool.getProperty('WHITELIST', None)
if not whitelist:
default = json.dumps(WHITELIST, indent=2)
stool.manage_addProperty('WHITELIST', default, 'text')
def queryResourceDirectory(type, name):
"""Find the IResourceDirectory of the given name and type. Returns
None if not found.
"""
# 1. Persistent resource directory:
# Try (persistent resource directory)/$type/$name
res = queryUtility(IResourceDirectory, name=u'persistent')
if res:
try:
return res[type][name]
except (KeyError, NotFound,):
pass # pragma: no cover
# 2. Global resource directory:
# Try (global resource directory)/$type/$name
res = queryUtility(IResourceDirectory, name=u'')
if res:
try:
return res[type][name]
except (KeyError, NotFound,):
pass # pragma: no cover
# 3. Packaged type-specific resource directory:
# Try (directory named after type + name)
identifier = u'++%s++%s' % (type, name)
res = queryUtility(IResourceDirectory, name=identifier)
if res is not None:
return res
return None
def test_global_components_not_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# Register FTI utility and factory utility
self.mock_utility(fti, IDexterityFTI, name=portal_type)
self.mock_utility(DexterityFactory(portal_type), IFactory, name=portal_type)
# We expect to always be able to unregister without error, even if the
# component exists. The factory is only unregistered if it was registered
# with info='plone.dexterity.dynamic'.
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
def generate(self):
"""the rendered feed.
@return: tuple of data and mimetype.
"""
producer = queryUtility(IFeedSkeletonProducer, name=self.name)
if producer is None:
return None, None
tree = producer()
named_modifiers = list(getAdapters((self.feed, tree), IFeedModifier))
named_modifiers.sort(key=operator.itemgetter(0))
namespaces = Set()
for name, modifier in named_modifiers:
ns = modifier.modify()
namespaces.update(ns)
mimetype = IMimeTypeLookup(tree)
prefixmap = {}
for ns in namespaces:
prefix = queryUtility(INamespacePrefix, name=ns)
if prefix is None:
continue
prefixmap[ns] = prefix
writer = XMLWriter(tree, prefixmap)
result = writer(), mimetype
return result
def purge(event):
"""Asynchronously send PURGE requests
"""
request = event.request
annotations = IAnnotations(request, None)
if annotations is None:
return
paths = annotations.get(KEY, None)
if paths is None:
return
registry = queryUtility(IRegistry)
if registry is None:
return
if not isCachePurgingEnabled(registry=registry):
return
purger = queryUtility(IPurger)
if purger is None:
return
settings = registry.forInterface(ICachePurgingSettings, check=False)
for path in paths:
for url in getURLsToPurge(path, settings.cachingProxies):
purger.purgeAsync(url)
def test_components_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1, None)
# We expect to always be able to unregister without error, even if the
# components do not exists (as here)
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name=portal_type)).passthrough()
self.replay()
# First add the components
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
# Then remove them again
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertEquals(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEquals(None, queryUtility(IFactory, name=portal_type))
def revisionfiles(self, unrestricted=False):
""" All the revision files, ordered """
if unrestricted:
catalog = getMultiAdapter((self.context, self.context.REQUEST), name=u'plone_tools').catalog()
items = catalog.unrestrictedSearchResults(**{'object_provides':IRevisionFile.__identifier__,
'sort_order':'getId',
'path':'/'.join(self.context.getPhysicalPath())})
else:
items = self.context.getFolderContents({'object_provides':IRevisionFile.__identifier__,
'sort_order':'getId',
})
items = sorted(items, key=attrgetter('effective'), reverse=True)
if items:
portal_type = items[0].portal_type
priority_utility = queryUtility(IRevisionWorkflowUtility, name=portal_type)
priority_utility = not priority_utility and queryUtility(IRevisionWorkflowUtility)
if priority_utility:
priority_map = priority_utility.priority_map()
try:
items = sorted(items, key=lambda x: (priority_map.get(x.review_state, {}).get('priority'), x.effective))
except TypeError:
# Missing.value on items[0].review_state
pass
items.reverse()
if unrestricted:
return [item._unrestrictedGetObject() for item in items]
else:
return [item.getObject() for item in items]
def test_ct_checkliste_schema(self):
fti = queryUtility(IDexterityFTI, name='Checkliste')
schema = fti.lookupSchema()
self.assertEqual(ICheckliste, schema)
def test_ct_contracting_process_schema(self):
fti = queryUtility(IDexterityFTI, name='Contracting Process')
schema = fti.lookupSchema()
self.assertEqual(IContractingProcess, schema)
def test_factory(self):
fti = queryUtility(IDexterityFTI, name='collective.conference.track')
factory = fti.factory
new_object = createObject(factory)
self.failUnless(ITrack.providedBy(new_object))
def test_schema(self):
fti = queryUtility(IDexterityFTI, name='collective.conference.track')
schema = fti.lookupSchema()
self.assertEquals(ITrack, schema)
def test_fti(self):
fti = queryUtility(IDexterityFTI, name='collective.conference.track')
self.assertNotEquals(None, fti)
def test_ct_checkliste_globally_not_addable(self):
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
fti = queryUtility(IDexterityFTI, name='Checkliste')
self.assertFalse(fti.global_allow,
u'{0} is globally addable!'.format(fti.id))
def test_ct_checkliste_fti(self):
fti = queryUtility(IDexterityFTI, name='Checkliste')
self.assertTrue(fti)
def caltool(self):
if PRODUCTS_CMFCALENDAR_INSTALLED:
return queryUtility(ICalendarTool)
return None
def tile_id(self):
return queryUtility(IIDNormalizer).normalize(
self.data.get('tile_title')
)
def uidtool(self):
if PRODUCTS_CMFUID_INSTALLED:
return queryUtility(IUniqueIdHandler)
return None
def edit_comment_allowed():
# Check if editing comments is allowed in the registry
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings, check=False)
return settings.edit_comment_enabled
def syndtool(self):
return queryUtility(ISyndicationTool)
import sys
from Testing.makerequest import makerequest
import transaction
from zope.component import queryUtility, queryMultiAdapter
from plone.i18n.normalizer.interfaces import IURLNormalizer
from Products.CMFPlone.utils import _createObjectByType
from AccessControl.SecurityManagement import \
newSecurityManager, noSecurityManager
from Products.PloneHelpCenter.interfaces import IHelpCenterContent
from Products.PloneHelpCenter.browser.helpcenter import HelpCenterView
normalize = queryUtility(IURLNormalizer).normalize
app = makerequest(app)
acl_users = app.acl_users
user = acl_users.getUser(adminUser)
if user:
user = user.__of__(acl_users)
newSecurityManager(None, user)
else:
print "Retrieving admin user failed"
sys.exit(1)
phc = app.unrestrictedTraverse(myPHC)
print phc
def permission_exists(permission_id):
permission = queryUtility(IPermission, permission_id)
return permission is not None
def test_ct_source_schema(self):
fti = queryUtility(IDexterityFTI, name='Source')
schema = fti.lookupSchema()
self.assertEqual(ISource, schema)
def sortProperties(self, strJson, indent=1):
""" Sort JSON properties
"""
utils = queryUtility(IVisualizationJsonUtils)
return utils.sortProperties(strJson, indent)
def title(self):
site = queryUtility(ISiteRoot)
if site is None:
# fallback
return aq_parent(aq_inner(self)).title
return site.title
def test_ct_source_fti(self):
fti = queryUtility(IDexterityFTI, name='Source')
self.assertTrue(fti)
def render(self):
currentValues = self.value or {}
criteria = self.getCriteria()
html = ''
for fieldid, selectedItems in [(a['i'], a['v']) for a in criteria]:
index = self.context.portal_atct.getIndex(fieldid)
fieldname = index.friendlyName or index.index
if selectedItems:
html += '<br/><b>%s</b><br/><table>' % (fieldname)
for item in selectedItems:
name = safe_unicode(item)
item = str(
component.queryUtility(IURLNormalizer).normalize(name))
value = ''
if fieldid in currentValues \
and item in currentValues[fieldid]:
value = currentValues[fieldid][item]
html += """<tr><td>%s </td><td>
<input type="text" size="10" name="%s:record" value="%s"
class="colorinput" style="background-color:%s;" />
</td></tr>""" % (name, self.name + '.' + fieldid + '.' +
item, value, value)
html += '</table>'
calendar = ISolgemaFullcalendarProperties(self.context, None)
gcalSourcesAttr = getattr(calendar, 'gcalSources', '')
if gcalSourcesAttr != None:
gcalSources = gcalSourcesAttr.split('\n')
if gcalSources:
html += '<br/><b>%s</b><br/><table>' % (
_('Google Calendar Sources'))
fieldid = 'gcalSources'
for i in range(len(gcalSources)):
url = gcalSources[i]
item = 'source' + str(i)
value = ''
if fieldid in currentValues \
and item in currentValues[fieldid]:
value = currentValues[fieldid][item]
html += """<tr><td><span title="%s">%s</span> </td></td><td>
<input type="text" size="10" name="%s:record" value="%s"
class="colorinput" style="background-color:%s;" />
</td></tr>""" % (str(url), 'Source ' + str(i + 1),
self.name + '.' + fieldid + '.' +
item, value, value)
html += '</table>'
availableSubFolders = getattr(calendar, 'availableSubFolders', [])
if IATFolder.providedBy(self.context) and availableSubFolders:
html += '<br/><b>%s</b><br/><table>' % (_('Sub-Folders'))
fieldid = 'subFolders'
for folderId in availableSubFolders:
value = ''
if fieldid in currentValues \
and folderId in currentValues[fieldid]:
value = currentValues[fieldid][folderId]
html += """<tr><td><span title="%s">%s</span> </td></td><td>
<input type="text" size="10" name="%s:record" value="%s"
class="colorinput" style="background-color:%s;" />
</td></tr>""" % (folderId, folderId, self.name + '.' +
fieldid + '.' + folderId, value, value)
html += '</table>'
return html
def searchMembers(self, search_param, search_term):
""" Search the membership """
mdtool = queryUtility(IMemberDataTool)
if mdtool is not None:
return mdtool.searchMemberData(search_param, search_term)
return None
def test_ct_notiz_schema(self):
fti = queryUtility(IDexterityFTI, name='Notiz')
schema = fti.lookupSchema()
self.assertEqual(INotiz, schema)
def get_portal_type_name_string(obj):
"""Returns the klass-attribute of the fti."""
fti = queryUtility(IDexterityFTI, name=obj.portal_type)
if not fti:
return False
return fti.klass
def test_factory(self):
fti = queryUtility(IDexterityFTI, name='Event')
factory = fti.factory
obj = createObject(factory)
self.assertTrue(IEvent.providedBy(obj))
def test_ct_notiz_fti(self):
fti = queryUtility(IDexterityFTI, name='Notiz')
self.assertTrue(fti)
def test_schema(self):
fti = queryUtility(IDexterityFTI, name='Event')
schema = fti.lookupSchema()
self.assertEqual(IEvent, schema)
def _makeOne(self):
from zope.component import queryUtility
from plone.i18n.locales.interfaces import ICountryAvailability
return queryUtility(ICountryAvailability)
def test_fti(self):
fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG)
self.assertTrue(fti)
def test_fti(self):
fti = queryUtility(IDexterityFTI, name='Event')
self.assertTrue(fti)
def test_schema(self):
fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG)
schema = fti.lookupSchema()
self.assertEqual(IDCATCatalog, schema)
def test_factory(self):
fti = queryUtility(IDexterityFTI, name=constants.CT_DCAT_CATALOG)
factory = fti.factory
obj = createObject(factory)
self.assertTrue(IDCATCatalog.providedBy(obj))
