def test_search_anonymous(self):
catalog = CatalogTool()
dummy = DummyContent(catalog=1)
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(0, len(catalog.searchResults()))
def test_search_anonymous(self):
catalog = CatalogTool()
dummy = DummyContent(catalog=1)
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(0, len(catalog.searchResults()))
def setUp(self):
from Products.CMFCore.CatalogTool import CatalogTool
from Products.CMFCore.utils import registerToolInterface
from Products.CMFUid.interfaces import IUniqueIdHandler
from Products.CMFUid.UniqueIdAnnotationTool \
import UniqueIdAnnotationTool
from Products.CMFUid.UniqueIdGeneratorTool \
import UniqueIdGeneratorTool
SecurityTest.setUp(self)
self.app._setObject('dummy', DummyContent(id='dummy'))
self.app._setObject('dummy2', DummyContent(id='dummy2'))
self.ctool = CatalogTool().__of__(self.app)
self.uidhandler = self._makeOne()
sm = getSiteManager()
sm.registerUtility(self.ctool, ICatalogTool)
registerToolInterface('portal_catalog', ICatalogTool)
sm.registerUtility(self.uidhandler, IUniqueIdHandler)
sm.registerUtility(UniqueIdAnnotationTool(),
IUniqueIdAnnotationManagement)
sm.registerUtility(UniqueIdGeneratorTool(), IUniqueIdGenerator)
sm.registerUtility(provided=IPortalCatalogQueueProcessor,
factory=PortalCatalogProcessor)
# Make sure we have our indices/columns
uid_name = self.uidhandler.UID_ATTRIBUTE_NAME
self.ctool.addIndex(uid_name, 'FieldIndex')
self.ctool.addColumn(uid_name)
def test_processActions( self ):
"""
Tracker #405: CatalogTool doesn't accept optional third
argument, 'idxs', to 'catalog_object'.
"""
tool = CatalogTool()
dummy = DummyContent(catalog=1)
tool.catalog_object( dummy, '/dummy' )
tool.catalog_object( dummy, '/dummy', [ 'SearchableText' ] )
def test_catalogUnindexAndIndex(self):
#
# Test is a new object does get cataloged upon _setObject
# and uncataloged upon manage_deleteObjects
#
test = self.root.test
self.root._setObject('portal_types', TypesTool())
types_tool = self.root.portal_types
self.root._setObject('portal_catalog', CatalogTool())
catalog = self.root.portal_catalog
assert len(catalog) == 0
test._setObject('foo', DummyContent('foo', catalog=1))
foo = test.foo
assert foo.after_add_called
assert not foo.before_delete_called
assert len(catalog) == 1
foo.reset()
test._delObject('foo')
assert not foo.after_add_called
assert foo.before_delete_called
assert len(catalog) == 0
def setUp(self):
from Products.CMFCore.CatalogTool import CatalogTool
from Products.CMFUid.UniqueIdAnnotationTool \
import UniqueIdAnnotationTool
from Products.CMFUid.UniqueIdGeneratorTool \
import UniqueIdGeneratorTool
SecurityTest.setUp(self)
self.root._setObject('portal_catalog', CatalogTool())
self.root._setObject('portal_uidgenerator', UniqueIdGeneratorTool())
self.root._setObject('portal_uidannotation', UniqueIdAnnotationTool())
self.root._setObject('portal_uidhandler', self._getTargetClass()())
self.root._setObject('dummy', DummyContent(id='dummy'))
self.root._setObject('dummy2', DummyContent(id='dummy2'))
sm = getSiteManager()
sm.registerUtility(self.root.portal_uidannotation,
IUniqueIdAnnotationManagement)
sm.registerUtility(self.root.portal_uidgenerator, IUniqueIdGenerator)
if indexing:
sm.registerUtility(provided=IPortalCatalogQueueProcessor,
factory=PortalCatalogProcessor)
# Make sure we have our indices/columns
uid_name = self.root.portal_uidhandler.UID_ATTRIBUTE_NAME
self.root.portal_catalog.addIndex(uid_name, 'FieldIndex')
self.root.portal_catalog.addColumn(uid_name)
def test_tracker261(self):
#
# Tracker issue #261 says that content in a deleted folder
# is not being uncatalogued. Try creating a subfolder with
# content object, and test.
#
from Products.CMFCore.PortalFolder import PortalFolder
test = self._makeOne('test')
ttool = self.site._setObject( 'portal_types', TypesTool() )
ctool = self.site._setObject( 'portal_catalog', CatalogTool() )
self.assertEqual( len(ctool), 0 )
test._setObject( 'sub', PortalFolder( 'sub', '' ) )
sub = test.sub
sub._setObject( 'foo', DummyContent( 'foo', catalog=1 ) )
foo = sub.foo
self.failUnless( foo.after_add_called )
self.failIf( foo.before_delete_called )
self.assertEqual( len(ctool), 1 )
foo.reset()
test.manage_delObjects( ids=['sub'] )
self.failIf( foo.after_add_called )
self.failUnless( foo.before_delete_called )
self.assertEqual( len(ctool), 0 )
def test_folderMove(self):
#
# Does the catalog stay synched when folders are moved?
#
test = self.root.test
self.root._setObject('portal_types', TypesTool())
types_tool = self.root.portal_types
self.root._setObject('portal_catalog', CatalogTool())
catalog = self.root.portal_catalog
assert len(catalog) == 0
test._setObject('folder', PortalFolder('folder', ''))
folder = test.folder
folder._setObject('sub', PortalFolder('sub', ''))
sub = folder.sub
sub._setObject('foo', DummyContent('foo', catalog=1))
foo = sub.foo
assert len(catalog) == 1
assert 'foo' in catalog.uniqueValuesFor('id')
assert has_path(catalog._catalog, '/test/folder/sub/foo')
# WAAAA! must get _p_jar set
old, sub._p_jar = sub._p_jar, self.root._p_jar
try:
folder.manage_renameObject(id='sub', new_id='new_sub')
finally:
sub._p_jar = old
assert 'foo' in catalog.uniqueValuesFor('id')
assert len(catalog) == 1
assert has_path(catalog._catalog, '/test/folder/new_sub/foo')
folder._setObject('bar', DummyContent('bar', catalog=1))
bar = folder.bar
assert 'bar' in catalog.uniqueValuesFor('id')
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/bar')
folder._setObject('sub2', PortalFolder('sub2', ''))
sub2 = folder.sub2
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = []
sub2.all_meta_types.extend(sub2.all_meta_types)
sub2.all_meta_types.extend(extra_meta_types())
# WAAAA! must get _p_jar set
old, bar._p_jar = sub._p_jar, self.root._p_jar
try:
cookie = folder.manage_cutObjects(ids=['bar'])
sub2.manage_pasteObjects(cookie)
finally:
bar._p_jar = old
assert 'foo' in catalog.uniqueValuesFor('id')
assert 'bar' in catalog.uniqueValuesFor('id')
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/sub2/bar')
def test_tracker261(self):
#
# Tracker issue #261 says that content in a deleted folder
# is not being uncatalogued. Try creating a subfolder with
# content object, and test.
#
self.root._setObject('test', PortalFolder('test', ''))
test = self.root.test
self.root._setObject('portal_catalog', CatalogTool())
catalog = self.root.portal_catalog
assert len(catalog) == 0
test._setObject('sub', PortalFolder('sub', ''))
sub = test.sub
sub._setObject('foo', DummyContent('foo', 1))
foo = sub.foo
assert foo.after_add_called
assert not foo.before_delete_called
assert len(catalog) == 1
foo.reset()
test.manage_delObjects(ids=['sub'])
assert not foo.after_add_called
assert foo.before_delete_called
assert len(catalog) == 0
def test_convertQuery(self):
convert = CatalogTool()._convertQuery
kw = {}
convert(kw)
self.assertEqual(kw, {})
kw = {'expires': 5, 'expires_usage': 'brrr:min'}
self.assertRaises(ValueError, convert, kw)
kw = {'foo': 'bar'}
convert(kw)
self.assertEqual(kw, {'foo': 'bar'})
kw = {'expires': 5, 'expires_usage': 'range:min'}
convert(kw)
self.assertEqual(kw, {'expires': {'query': 5, 'range': 'min'}})
kw = {'expires': 5, 'expires_usage': 'range:max'}
convert(kw)
self.assertEqual(kw, {'expires': {'query': 5, 'range': 'max'}})
kw = {'expires': (5, 7), 'expires_usage': 'range:min:max'}
convert(kw)
self.assertEqual(kw,
{'expires': {
'query': (5, 7),
'range': 'min:max'
}})
def setUp(self):
from Products.CMFCore.CatalogTool import CatalogTool
from Products.CMFCore.utils import registerToolInterface
from Products.CMFUid.interfaces import IUniqueIdHandler
from Products.CMFUid.UniqueIdAnnotationTool \
import UniqueIdAnnotationTool
from Products.CMFUid.UniqueIdGeneratorTool \
import UniqueIdGeneratorTool
SecurityTest.setUp(self)
self.app._setObject('dummy', DummyContent(id='dummy'))
self.app._setObject('dummy2', DummyContent(id='dummy2'))
self.ctool = CatalogTool().__of__(self.app)
self.uidhandler = self._makeOne()
sm = getSiteManager()
sm.registerUtility(self.ctool, ICatalogTool)
registerToolInterface('portal_catalog', ICatalogTool)
sm.registerUtility(self.uidhandler, IUniqueIdHandler)
sm.registerUtility(UniqueIdAnnotationTool(),
IUniqueIdAnnotationManagement)
sm.registerUtility(UniqueIdGeneratorTool(), IUniqueIdGenerator)
sm.registerUtility(provided=IPortalCatalogQueueProcessor, factory=PortalCatalogProcessor)
# Make sure we have our indices/columns
uid_name = self.uidhandler.UID_ATTRIBUTE_NAME
self.ctool.addIndex(uid_name, 'FieldIndex')
self.ctool.addColumn(uid_name)
def test_itemCataloguing(self):
ctool = self.site._setObject('portal_catalog', CatalogTool())
dtool = self.site.portal_discussion
catalog = ctool._catalog
test = self._makeDummyContent('test', catalog=1)
test.allow_discussion = 1
self.assertEqual(len(ctool), 1)
self.failUnless(has_path(catalog, test.getPhysicalPath()))
talkback = dtool.getDiscussionFor(test)
self.assertEqual(talkback.getPhysicalPath(),
('', 'bar', 'site', 'test', 'talkback'))
talkback.createReply(title='test', text='blah')
self.assertEqual(len(ctool), 2)
for reply in talkback.getReplies():
self.failUnless(has_path(catalog, reply.getPhysicalPath()))
self.failUnless(
has_path(catalog,
'/bar/site/test/talkback/%s' % reply.getId()))
reply1 = talkback.getReplies()[0]
talkback1 = dtool.getDiscussionFor(reply1)
talkback1.createReply(title='test2', text='blah2')
for reply in talkback.getReplies():
self.failUnless(has_path(catalog, reply.getPhysicalPath()))
self.failUnless(
has_path(catalog,
'/bar/site/test/talkback/%s' % reply.getId()))
for reply in talkback1.getReplies():
self.failUnless(has_path(catalog, reply.getPhysicalPath()))
self.failUnless(
has_path(catalog,
'/bar/site/test/talkback/%s' % reply.getId()))
def _initSite(self, foo=2):
site = self.root.site = Folder(id='site')
ctool = site.portal_catalog = CatalogTool()
sm = getSiteManager(site)
sm.registerUtility(ctool, ICatalogTool)
for obj_id in ctool.objectIds():
ctool._delObject(obj_id)
for idx_id in ctool.indexes():
ctool.delIndex(idx_id)
for col in ctool.schema()[:]:
ctool.delColumn(col)
if foo > 0:
ctool._setObject('foo_plexicon', PLexicon('foo_plexicon'))
lex = ctool.foo_plexicon
lex._pipeline = (Splitter(), CaseNormalizer(), StopWordRemover())
extra = _extra()
extra.lexicon_id = 'foo_plexicon'
extra.index_type = 'Okapi BM25 Rank'
ctool.addIndex('foo_zctext', 'ZCTextIndex', extra)
ctool.addColumn('foo_zctext')
return site
def test_contentPaste(self):
#
# Does copy / paste work?
#
sm = getSiteManager(self.site)
ctool = self.site._setObject( 'portal_catalog', CatalogTool() )
sm.registerUtility(ctool, ICatalogTool)
ttool = self.site._setObject( 'portal_types', TypesTool() )
sm.registerUtility(ttool, ITypesTool)
fti = FTIDATA_DUMMY[0].copy()
ttool._setObject( 'Dummy Content', FTI(**fti) )
sub1 = self._makeOne('sub1')
sub2 = self._makeOne('sub2')
sub3 = self._makeOne('sub3')
self.assertEqual( len(ctool), 0 )
sub1._setObject( 'dummy', DummyContent( 'dummy', catalog=1 ) )
self.failUnless( 'dummy' in sub1.objectIds() )
self.failUnless( 'dummy' in sub1.contentIds() )
self.failIf( 'dummy' in sub2.objectIds() )
self.failIf( 'dummy' in sub2.contentIds() )
self.failIf( 'dummy' in sub3.objectIds() )
self.failIf( 'dummy' in sub3.contentIds() )
self.failUnless( has_path(ctool._catalog, '/bar/site/sub1/dummy') )
self.failIf( has_path(ctool._catalog, '/bar/site/sub2/dummy') )
self.failIf( has_path(ctool._catalog, '/bar/site/sub3/dummy') )
cookie = sub1.manage_copyObjects( ids = ( 'dummy', ) )
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = []
sub2.all_meta_types.extend( sub2.all_meta_types )
sub2.all_meta_types.extend( extra_meta_types() )
sub2.manage_pasteObjects( cookie )
self.failUnless( 'dummy' in sub1.objectIds() )
self.failUnless( 'dummy' in sub1.contentIds() )
self.failUnless( 'dummy' in sub2.objectIds() )
self.failUnless( 'dummy' in sub2.contentIds() )
self.failIf( 'dummy' in sub3.objectIds() )
self.failIf( 'dummy' in sub3.contentIds() )
self.failUnless( has_path(ctool._catalog, '/bar/site/sub1/dummy') )
self.failUnless( has_path(ctool._catalog, '/bar/site/sub2/dummy') )
self.failIf( has_path(ctool._catalog, '/bar/site/sub3/dummy') )
transaction.savepoint(optimistic=True)
cookie = sub1.manage_cutObjects( ids = ('dummy',) )
# Waaa! force sub2 to allow paste of Dummy object.
sub3.all_meta_types = []
sub3.all_meta_types.extend(sub3.all_meta_types)
sub3.all_meta_types.extend( extra_meta_types() )
sub3.manage_pasteObjects(cookie)
self.failIf( 'dummy' in sub1.objectIds() )
self.failIf( 'dummy' in sub1.contentIds() )
self.failUnless( 'dummy' in sub2.objectIds() )
self.failUnless( 'dummy' in sub2.contentIds() )
self.failUnless( 'dummy' in sub3.objectIds() )
self.failUnless( 'dummy' in sub3.contentIds() )
self.failIf( has_path(ctool._catalog, '/bar/site/sub1/dummy') )
self.failUnless( has_path(ctool._catalog, '/bar/site/sub2/dummy') )
self.failUnless( has_path(ctool._catalog, '/bar/site/sub3/dummy') )
def test_folderMove( self ):
#
# Does the catalog stay synched when folders are moved?
#
from Products.CMFCore.PortalFolder import PortalFolder
test = self.root.test
self.root._setObject( 'portal_types', TypesTool() )
types_tool = self.root.portal_types
self.root._setObject( 'portal_catalog', CatalogTool() )
catalog = self.root.portal_catalog
assert len( catalog ) == 0
test._setObject( 'folder', PortalFolder( 'folder', '' ) )
folder = test.folder
folder._setObject( 'sub', PortalFolder( 'sub', '' ) )
sub = folder.sub
sub._setObject( 'foo', DummyContent( 'foo', catalog=1 ) )
foo = sub.foo
assert len( catalog ) == 1
assert 'foo' in catalog.uniqueValuesFor( 'id' )
assert has_path( catalog._catalog, '/test/folder/sub/foo' )
# WAAAA! must get _p_jar set
# XXX This is broken with ZODB 3.3+, use a subtransaction
# old, sub._p_jar = sub._p_jar, self.root._p_jar
get_transaction().commit(1)
folder.manage_renameObject( id='sub', new_id='new_sub' )
assert 'foo' in catalog.uniqueValuesFor( 'id' )
assert len( catalog ) == 1
assert has_path( catalog._catalog, '/test/folder/new_sub/foo' )
folder._setObject( 'bar', DummyContent( 'bar', catalog=1 ) )
bar = folder.bar
assert 'bar' in catalog.uniqueValuesFor( 'id' )
assert len( catalog ) == 2
assert has_path( catalog._catalog, '/test/folder/bar' )
folder._setObject( 'sub2', PortalFolder( 'sub2', '' ) )
sub2 = folder.sub2
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = []
sub2.all_meta_types.extend( sub2.all_meta_types )
sub2.all_meta_types.extend( extra_meta_types() )
# WAAAA! must get _p_jar set
# XXX This is broken with ZODB 3.3+, use a subtransaction
# old, bar._p_jar = sub._p_jar, self.root._p_jar
get_transaction().commit(1)
cookie = folder.manage_cutObjects( ids=['bar'] )
sub2.manage_pasteObjects( cookie )
assert 'foo' in catalog.uniqueValuesFor( 'id' )
assert 'bar' in catalog.uniqueValuesFor( 'id' )
assert len( catalog ) == 2
assert has_path( catalog._catalog, '/test/folder/sub2/bar' )
def __init__(self, FULLTEXT=False):
"""
"""
self.no_refresh = True
CatalogTool.__init__(self)
self._catalog = PlominoCatalog()
lexicon = PLexicon("plaintext_lexicon", "", Splitter(), CaseNormalizer())
self._setObject("plaintext_lexicon", lexicon)
self.addIndex("Form", "FieldIndex")
self.addIndex("id", "FieldIndex")
self.addColumn("id")
self.addIndex("getPlominoReaders", "KeywordIndex")
self.addIndex("path", "ExtendedPathIndex")
if FULLTEXT:
self.createFieldIndex("SearchableText", "RICHTEXT")
self.no_refresh = False
def setUp(self):
SecurityTest.setUp(self)
self.root._setObject('portal_catalog', CatalogTool())
self.root._setObject('portal_uidgenerator', UniqueIdGeneratorTool())
self.root._setObject('portal_uidhandler', UniqueIdHandlerTool())
self.root._setObject('dummy', DummyContent(id='dummy'))
self.uid_attr_name = self.root.portal_uidhandler._UID_ATTRIBUTE_NAME
setupIndexes(self.root.portal_catalog, self.uid_attr_name)
def setUp(self):
SecurityTest.setUp(self)
self.root._setObject('portal_catalog', CatalogTool())
self.root._setObject('portal_uidgenerator', UniqueIdGeneratorTool())
self.root._setObject('portal_uidannotation', UniqueIdAnnotationTool())
self.root._setObject('portal_uidhandler', UniqueIdHandlerTool())
self.root._setObject('dummy', DummyContent(id='dummy'))
removeUnnecessaryIndexes(self.root.portal_catalog)
def backlinkTools():
import Products.CMFCore.utils
Products.CMFCore.utils.getToolByName = getToolByName
from Products.CMFCore.CatalogTool import CatalogTool
from Products.Archetypes.ReferenceEngine import ReferenceCatalog, UIDCatalog
return dict(portal_workflow=None,
portal_catalog=CatalogTool(),
reference_catalog=ReferenceCatalog(id='portal_reference'),
portal_uid=UIDCatalog(id='portal_uid'))
def __init__(self, FULLTEXT=False):
"""
"""
self.no_refresh = True
CatalogTool.__init__(self)
self._catalog = PlominoCatalog()
lexicon = PLexicon('plaintext_lexicon', '', Splitter(),
CaseNormalizer())
self._setObject('plaintext_lexicon', lexicon)
self.addIndex('Form', "FieldIndex")
self.addIndex('id', "FieldIndex")
self.addColumn('id')
self.addIndex('getPlominoReaders', "KeywordIndex")
self.addIndex('path', "ExtendedPathIndex")
if FULLTEXT:
self.createFieldIndex('SearchableText', 'RICHTEXT')
self.no_refresh = False
def test_itemCataloguing(self):
ctool = CatalogTool()
ctool.addColumn('in_reply_to')
getSiteManager().registerUtility(ctool, ICatalogTool)
dtool = self.dtool
test = self._makeDummyContent('test', catalog=1)
test.allow_discussion = 1
self.assertEqual( len(ctool), 1 )
self.failUnless(has_path(ctool, test.getPhysicalPath()))
talkback = dtool.getDiscussionFor(test)
self.assertEqual( talkback.getPhysicalPath(),
('', 'bar', 'site', 'test', 'talkback') )
talkback.createReply( title='test'
, text='blah'
)
self.assertEqual( len(ctool), 2 )
for reply in talkback.getReplies():
self.failUnless(has_path(ctool, reply.getPhysicalPath()))
self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
% reply.getId()))
reply1 = talkback.getReplies()[0]
path1 = '/'.join(reply1.getPhysicalPath())
self.assertEqual( ctool.getMetadataForUID(path1),
{'in_reply_to': None} )
talkback1 = dtool.getDiscussionFor(reply1)
talkback1.createReply( title='test2'
, text='blah2'
)
for reply in talkback.getReplies():
self.failUnless(has_path(ctool, reply.getPhysicalPath()))
self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
% reply.getId()))
for reply in talkback1.getReplies():
self.failUnless(has_path(ctool, reply.getPhysicalPath()))
self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
% reply.getId()))
reply2 = talkback1.getReplies()[0]
path2 = '/'.join(reply2.getPhysicalPath())
self.assertEqual( ctool.getMetadataForUID(path2),
{'in_reply_to': reply1.getId()} )
def test_portalfolder_cataloging(self):
#
# Test to ensure a portal folder itself is *not* cataloged upon
# instantiation (Tracker issue 309)
#
ttool = self.site._setObject('portal_types', TypesTool())
ctool = self.site._setObject('portal_catalog', CatalogTool())
wftool = self.site._setObject('portal_workflow', WorkflowTool())
test = self._makeOne('test')
wftool.notifyCreated(test)
self.assertEqual(len(ctool), 0)
def setUp(self):
self.site = DummySite('site')
self.site._path = ''
self.site._setObject('portal_catalog', CatalogTool())
self.site.portal_catalog.addIndex('state', 'KeywordIndex')
self.site._setObject('portal_types', DummyTool())
self.site._setObject('portal_workflow', WorkflowTool())
self.site._setObject('dummy', DummyContent('dummy'))
self.site.dummy.state = 'private'
self.site.portal_catalog.catalog_object(self.site.dummy)
self._constructDummyWorkflow()
def test_deletePropagation(self):
ctool = self.site._setObject('portal_catalog', CatalogTool())
dtool = self.site.portal_discussion
test = self._makeDummyContent('test', catalog=1)
test.allow_discussion = 1
talkback = dtool.getDiscussionFor(test)
talkback.createReply(title='test', text='blah')
self.assertEqual(len(ctool), 2)
self.site._delObject('test')
self.assertEqual(len(ctool), 0)
def test_deletePropagation(self):
ctool = CatalogTool()
getSiteManager().registerUtility(ctool, ICatalogTool)
dtool = self.dtool
test = self._makeDummyContent('test', catalog=1)
test.allow_discussion = 1
talkback = dtool.getDiscussionFor(test)
talkback.createReply(title='test', text='blah')
self.assertEqual(len(ctool), 2)
self.site._delObject('test')
self.assertEqual(len(ctool), 0)
def __init__(self, FULLTEXT=False):
"""
"""
self.no_refresh = True
CatalogTool.__init__(self)
self._catalog = PlominoCatalog()
lexicon = PLexicon(
'plaintext_lexicon',
'',
Splitter(),
CaseNormalizer())
self._setObject('plaintext_lexicon', lexicon)
self.addIndex('Form', "FieldIndex")
self.addIndex('id', "FieldIndex")
self.addColumn('id')
self.addIndex('getPlominoReaders', "KeywordIndex")
self.addIndex('path', "ExtendedPathIndex")
if FULLTEXT:
self.createFieldIndex('SearchableText', 'RICHTEXT')
self.no_refresh = False
def test_folderMove(self):
#
# Does the catalog stay synched when folders are moved?
#
test = self.root.test
self.root._setObject('portal_types', TypesTool())
types_tool = self.root.portal_types
self.root._setObject('portal_catalog', CatalogTool())
catalog = self.root.portal_catalog
assert len(catalog) == 0
test._setObject('folder', PortalFolder('folder', ''))
folder = test.folder
folder._setObject('sub', PortalFolder('sub', ''))
sub = folder.sub
sub._setObject('foo', DummyContent('foo', catalog=1))
foo = sub.foo
assert len(catalog) == 1
self.failUnless('foo' in catalog.uniqueValuesFor('getId'))
assert has_path(catalog._catalog, '/test/folder/sub/foo')
get_transaction().commit(1)
folder.manage_renameObject(id='sub', new_id='new_sub')
self.failUnless('foo' in catalog.uniqueValuesFor('getId'))
assert len(catalog) == 1
assert has_path(catalog._catalog, '/test/folder/new_sub/foo')
folder._setObject('bar', DummyContent('bar', catalog=1))
bar = folder.bar
self.failUnless('bar' in catalog.uniqueValuesFor('getId'))
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/bar')
folder._setObject('sub2', PortalFolder('sub2', ''))
sub2 = folder.sub2
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = []
sub2.all_meta_types.extend(sub2.all_meta_types)
sub2.all_meta_types.extend(extra_meta_types())
get_transaction().commit(1)
cookie = folder.manage_cutObjects(ids=['bar'])
sub2.manage_pasteObjects(cookie)
self.failUnless('foo' in catalog.uniqueValuesFor('getId'))
self.failUnless('bar' in catalog.uniqueValuesFor('getId'))
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/sub2/bar')
def setUp(self):
from Products.CMFCore.CatalogTool import CatalogTool
from Products.CMFUid.UniqueIdAnnotationTool \
import UniqueIdAnnotationTool
from Products.CMFUid.UniqueIdGeneratorTool \
import UniqueIdGeneratorTool
SecurityTest.setUp(self)
self.root._setObject('portal_catalog', CatalogTool())
self.root._setObject('portal_uidgenerator', UniqueIdGeneratorTool())
self.root._setObject('portal_uidannotation', UniqueIdAnnotationTool())
self.root._setObject('portal_uidhandler', self._getTargetClass()())
self.root._setObject('dummy', DummyContent(id='dummy'))
self.root._setObject('dummy2', DummyContent(id='dummy2'))
def enumerateIndexes(self):
standard = CatalogTool.enumerateIndexes(self)
custom = (('status', 'FieldIndex'), ('topic', 'FieldIndex'),
('classification', 'FieldIndex'), ('importance',
'FieldIndex'),
('security_related', 'FieldIndex'), ('confidential',
'FieldIndex'),
('resolution', 'TextIndex'), ('submitter_id', 'FieldIndex'),
('submitter_email', 'FieldIndex'), ('version_info',
'TextIndex'),
('assigned_to', 'KeywordIndex'), ('upload_number',
'KeywordIndex'))
return standard + custom
def test_folderMove(self):
#
# Does the catalog stay synched when folders are moved?
#
from Products.CMFCore.PortalFolder import PortalFolder
sm = getSiteManager(self.site)
ttool = self.site._setObject( 'portal_types', TypesTool() )
sm.registerUtility(ttool, ITypesTool)
ctool = self.site._setObject( 'portal_catalog', CatalogTool() )
sm.registerUtility(ctool, ICatalogTool)
ctool.addIndex('getId', 'FieldIndex')
self.assertEqual( len(ctool), 0 )
folder = self._makeOne('folder')
folder._setObject( 'sub', PortalFolder( 'sub', '' ) )
folder.sub._setObject( 'foo', DummyContent( 'foo', catalog=1 ) )
self.assertEqual( len(ctool), 1 )
self.failUnless( 'foo' in ctool.uniqueValuesFor('getId') )
self.failUnless( has_path(ctool._catalog,
'/bar/site/folder/sub/foo') )
transaction.savepoint(optimistic=True)
folder.manage_renameObject(id='sub', new_id='new_sub')
self.assertEqual( len(ctool), 1 )
self.failUnless( 'foo' in ctool.uniqueValuesFor('getId') )
self.failUnless( has_path(ctool._catalog,
'/bar/site/folder/new_sub/foo') )
folder._setObject( 'bar', DummyContent( 'bar', catalog=1 ) )
self.assertEqual( len(ctool), 2 )
self.failUnless( 'bar' in ctool.uniqueValuesFor('getId') )
self.failUnless( has_path(ctool._catalog, '/bar/site/folder/bar') )
folder._setObject( 'sub2', PortalFolder( 'sub2', '' ) )
sub2 = folder.sub2
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = []
sub2.all_meta_types.extend( sub2.all_meta_types )
sub2.all_meta_types.extend( extra_meta_types() )
transaction.savepoint(optimistic=True)
cookie = folder.manage_cutObjects(ids=['bar'])
sub2.manage_pasteObjects(cookie)
self.failUnless( 'foo' in ctool.uniqueValuesFor('getId') )
self.failUnless( 'bar' in ctool.uniqueValuesFor('getId') )
self.assertEqual( len(ctool), 2 )
self.failUnless( has_path(ctool._catalog,
'/bar/site/folder/sub2/bar') )
def setUp(self):
get_transaction().begin()
self._policy = UnitTestSecurityPolicy()
SecurityManager.setSecurityPolicy(self._policy)
self.root = Zope.app()
self.root._setObject('portal_discussion', DiscussionTool())
self.discussion_tool = self.root.portal_discussion
self.root._setObject('portal_catalog', CatalogTool())
self.catalog_tool = self.root.portal_catalog
self.root._setObject('portal_url', URLTool())
self.url_tool = self.root.portal_url
self.root._setObject('portal_workflow', WorkflowTool())
self.workflow_tool = self.root.portal_workflow
self.root._setObject('portal_types', TypesTool())
types_tool = self.types_tool = self.root.portal_types
def test_processActions(self):
"""
Tracker #405: CatalogTool doesn't accept optional third
argument, 'idxs', to 'catalog_object'.
"""
tool = CatalogTool()
dummy = DummyContent(catalog=1)
tool.catalog_object(dummy, '/dummy')
tool.catalog_object(dummy, '/dummy', ['SearchableText'])
def test_deleteReplies(self):
sm = getSiteManager()
dtool = self.site.portal_discussion
ctool = self.site._setObject( 'portal_catalog', CatalogTool() )
sm.registerUtility(ctool, ICatalogTool)
test = self._makeDummyContent('test')
test.allow_discussion = 1
# Create a structure 6 levels deep for testing
talkback = dtool.getDiscussionFor(test)
id1 = talkback.createReply(title='test1', text='blah')
reply1 = talkback.getReply(id1)
talkback1 = dtool.getDiscussionFor(reply1)
id2 = talkback1.createReply(title='test2', text='blah')
reply2 = talkback1.getReply(id2)
talkback2 = dtool.getDiscussionFor(reply2)
id3 = talkback2.createReply(title='test3', text='blah')
reply3 = talkback2.getReply(id3)
talkback3 = dtool.getDiscussionFor(reply3)
id4 = talkback3.createReply(title='test4', text='blah')
reply4 = talkback3.getReply(id4)
talkback4 = dtool.getDiscussionFor(reply4)
id5 = talkback4.createReply(title='test5', text='blah')
reply5 = talkback4.getReply(id5)
talkback5 = dtool.getDiscussionFor(reply5)
id6 = talkback5.createReply(title='test6', text='blah')
reply6 = talkback5.getReply(id6)
talkback6 = dtool.getDiscussionFor(reply6)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback1.getReplies()), 1)
self.assertEqual(len(talkback2.getReplies()), 1)
self.assertEqual(len(talkback3.getReplies()), 1)
self.assertEqual(len(talkback4.getReplies()), 1)
self.assertEqual(len(talkback5.getReplies()), 1)
self.assertEqual(len(talkback6.getReplies()), 0)
self.assertEqual(len(ctool), 7)
talkback3.deleteReply(id4)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback1.getReplies()), 1)
self.assertEqual(len(talkback2.getReplies()), 1)
self.assertEqual(len(talkback3.getReplies()), 0)
self.assertEqual(len(ctool), 4)
talkback.deleteReply(id1)
self.assertEqual(len(talkback.getReplies()), 0)
self.assertEqual(len(ctool), 1)
def enumerateIndexes(self):
standard = CatalogTool.enumerateIndexes(self)
custom = (('status', 'FieldIndex'),
('topic', 'FieldIndex'),
('classification', 'FieldIndex'),
('importance', 'FieldIndex'),
('security_related', 'FieldIndex'),
('confidential', 'FieldIndex'),
('resolution', 'TextIndex'),
('submitter_id', 'FieldIndex'),
('submitter_email', 'FieldIndex'),
('version_info', 'TextIndex'),
('assigned_to', 'KeywordIndex'),
('upload_number', 'KeywordIndex')
)
return standard + custom
def enumerateColumns( self ):
"""Return field names of data to be cached on query results."""
standard = CatalogTool.enumerateColumns(self)
custom = ('status',
'submitter_id',
'topic',
'classification',
'importance',
'security_related',
'confidential',
'version_info',
'assigned_to',
'uploads',
'action_number',
'upload_number',
)
return standard + custom
def test_folderMove(self):
#
# Does the catalog stay synched when folders are moved?
#
self.root._setObject('test', PortalFolder('test', ''))
test = self.root.test
self.root._setObject('portal_catalog', CatalogTool())
catalog = self.root.portal_catalog
assert len(catalog) == 0
test._setObject('folder', PortalFolder('folder', ''))
folder = test.folder
folder._setObject('sub', PortalFolder('sub', ''))
sub = folder.sub
sub._setObject('foo', DummyContent('foo', 1))
foo = sub.foo
assert len(catalog) == 1
assert 'foo' in catalog.uniqueValuesFor('id')
assert has_path(catalog._catalog, '/test/folder/sub/foo')
folder.manage_renameObject(id='sub', new_id='new_sub')
assert 'foo' in catalog.uniqueValuesFor('id')
assert len(catalog) == 1
assert has_path(catalog._catalog, '/test/folder/new_sub/foo')
folder._setObject('bar', DummyContent('bar', 1))
bar = folder.bar
assert 'bar' in catalog.uniqueValuesFor('id')
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/bar')
folder._setObject('sub2', PortalFolder('sub2', ''))
sub2 = folder.sub2
# Waaa! force sub2 to allow paste of Dummy object.
sub2.all_meta_types = sub2.all_meta_types() + extra_meta_types()
cookie = folder.manage_cutObjects(ids=['bar'])
sub2.manage_pasteObjects(cookie)
assert 'foo' in catalog.uniqueValuesFor('id')
assert 'bar' in catalog.uniqueValuesFor('id')
assert len(catalog) == 2
assert has_path(catalog._catalog, '/test/folder/sub2/bar')
def enumerateColumns( self ):
"""Return field names of data to be cached on query results."""
standard = CatalogTool.enumerateColumns(self)
custom = ('status',
'submitter_id',
'topic',
'classification',
'importance',
'security_related',
'confidential',
'version_info',
'assigned_to',
'uploads',
'action_number',
'upload_number',
)
return standard + custom
def setUp( self ):
SecurityTest.setUp(self)
root = self.root
root._setObject( 'portal_discussion', DiscussionTool() )
self.discussion_tool = root.portal_discussion
root._setObject( 'portal_catalog', CatalogTool() )
self.catalog_tool = root.portal_catalog
root._setObject( 'portal_url', URLTool() )
self.url_tool = root.portal_url
root._setObject( 'portal_workflow', WorkflowTool() )
self.workflow_tool = root.portal_workflow
root._setObject( 'portal_types', TypesTool() )
types_tool = self.types_tool = root.portal_types
try: root._delObject('test')
except AttributeError: pass
root._setObject( 'test', Document( 'test' ) )
def test_search_inactive(self):
catalog = CatalogTool()
now = DateTime()
dummy = DummyContent(catalog=1)
dummy._View_Permission = ('Blob',)
self.loginWithRoles('Blob')
# not yet effective
dummy.effective = now+1
dummy.expires = now+2
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(0, len(catalog.searchResults()))
# already expired
dummy.effective = now-2
dummy.expires = now-1
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(0, len(catalog.searchResults()))
def enumerateIndexes(self):
from Products.CMFCore.utils import SimpleRecord
plaintext_extra = SimpleRecord( lexicon_id='plaintext_lexicon'
, index_type='Okapi BM25 Rank'
)
standard = CatalogTool.enumerateIndexes(self)
custom = (('status', 'FieldIndex', None),
('topic', 'FieldIndex', None),
('classification', 'FieldIndex', None),
('importance', 'FieldIndex', None),
('security_related', 'FieldIndex', None),
('confidential', 'FieldIndex', None),
('resolution', 'ZCTextIndex', plaintext_extra),
('submitter_id', 'FieldIndex', None),
('submitter_email', 'FieldIndex', None),
('version_info', 'ZCTextIndex', plaintext_extra),
('assigned_to', 'KeywordIndex', None),
('upload_number', 'KeywordIndex', None)
)
if len(standard[0]) == 2:
# BBB compatibility with *old* CMFCore.CatalogTool
standard = tuple([index_tuple + (None,)
for index_tuple in standard])
return standard + custom
def test_search_restrict_manager(self):
catalog = CatalogTool()
now = DateTime()
dummy = DummyContent(catalog=1)
self.loginManager()
# already expired
dummy.effective = now-4
dummy.expires = now-2
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(1, len(catalog.searchResults()))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-3, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now-1, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now-3, 'range': 'max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-1, 'range': 'max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': (now-3, now-1), 'range': 'min:max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': (now-3, now-1), 'range': 'minmax'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-2})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-2, 'range': None})))
class UniqueIdHandlerTests(SecurityTest):
def _getTargetClass(self):
from Products.CMFUid.UniqueIdHandlerTool import UniqueIdHandlerTool
return UniqueIdHandlerTool
def _makeOne(self, *args, **kw):
return self._getTargetClass()(*args, **kw)
def setUp(self):
from Products.CMFCore.CatalogTool import CatalogTool
from Products.CMFUid.interfaces import IUniqueIdHandler
from Products.CMFUid.UniqueIdAnnotationTool \
import UniqueIdAnnotationTool
from Products.CMFUid.UniqueIdGeneratorTool \
import UniqueIdGeneratorTool
SecurityTest.setUp(self)
self.app._setObject('dummy', DummyContent(id='dummy'))
self.app._setObject('dummy2', DummyContent(id='dummy2'))
self.ctool = CatalogTool().__of__(self.app)
self.uidhandler = self._makeOne()
sm = getSiteManager()
sm.registerUtility(self.ctool, ICatalogTool)
sm.registerUtility(self.uidhandler, IUniqueIdHandler)
sm.registerUtility(UniqueIdAnnotationTool(),
IUniqueIdAnnotationManagement)
sm.registerUtility(UniqueIdGeneratorTool(), IUniqueIdGenerator)
# Make sure we have our indices/columns
uid_name = self.uidhandler.UID_ATTRIBUTE_NAME
self.ctool.addIndex(uid_name, 'FieldIndex')
self.ctool.addColumn(uid_name)
def tearDown(self):
cleanUp()
SecurityTest.tearDown(self)
def test_interfaces(self):
from Products.CMFUid.interfaces import IUniqueIdBrainQuery
from Products.CMFUid.interfaces import IUniqueIdHandler
from Products.CMFUid.interfaces import IUniqueIdUnrestrictedQuery
verifyClass(IUniqueIdBrainQuery, self._getTargetClass())
verifyClass(IUniqueIdHandler, self._getTargetClass())
verifyClass(IUniqueIdUnrestrictedQuery, self._getTargetClass())
def test_getUidOfNotYetRegisteredObject(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
self.assertEqual(handler.queryUid(dummy, None), None)
self.assertRaises(UniqueIdError, handler.getUid, dummy)
def test_getInvalidUid(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
self.assertEqual(handler.queryObject(100, None), None)
self.assertRaises(UniqueIdError, handler.getObject, 100)
self.assertEqual(handler.unrestrictedQueryObject(100, None), None)
self.assertRaises(UniqueIdError, handler.unrestrictedGetObject, 100)
uid = handler.register(dummy)
self.assertEqual(handler.queryObject(uid + 1, None), None)
self.assertRaises(UniqueIdError, handler.getObject, uid + 1)
self.assertEqual(handler.unrestrictedQueryObject(uid + 1, None), None)
self.assertRaises(UniqueIdError, handler.unrestrictedGetObject, uid + 1)
def test_getUidOfRegisteredObject(self):
handler = self.uidhandler
dummy = self.app.dummy
uid = handler.register(dummy)
self.assertEqual(handler.getUid(dummy), uid)
def test_getRegisteredObjectByUid(self):
handler = self.uidhandler
dummy = self.app.dummy
uid = handler.register(dummy)
self.assertEqual(handler.getObject(uid), dummy)
self.assertEqual(handler.unrestrictedGetObject(uid), dummy)
def test_getUnregisteredObject(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
uid = handler.register(dummy)
handler.unregister(dummy)
self.assertEqual(handler.queryObject(uid, None), None)
self.assertRaises(UniqueIdError, handler.getObject, uid)
self.assertEqual(handler.unrestrictedQueryObject(uid, None), None)
self.assertRaises(UniqueIdError, handler.unrestrictedGetObject, uid)
def test_getUidOfUnregisteredObject(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
handler.register(dummy)
handler.unregister(dummy)
self.assertEqual(handler.queryUid(dummy, None), None)
self.assertRaises(UniqueIdError, handler.getUid, dummy)
def test_reregisterObject(self):
handler = self.uidhandler
dummy = self.app.dummy
uid1_reg = handler.register(dummy)
uid1_get = handler.getUid(dummy)
uid2_reg = handler.register(dummy)
uid2_get = handler.getUid(dummy)
self.assertEqual(uid1_reg, uid2_reg)
self.assertEqual(uid1_get, uid2_get)
self.assertEqual(uid1_reg, uid1_get)
def test_unregisterObjectWithoutUid(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
self.assertRaises(UniqueIdError, handler.unregister, dummy)
def test_setNewUidByHandWithCheck(self):
handler = self.uidhandler
dummy = self.app.dummy
# registering and unregisterung a object just to get a free uid
unused_uid = handler.register(dummy)
handler.unregister(dummy)
handler.setUid(dummy, unused_uid)
result = handler.getUid(dummy)
self.assertEqual(unused_uid, result)
def test_setSameUidOnSameObjectWithCheck(self):
handler = self.uidhandler
dummy = self.app.dummy
uid = handler.register(dummy)
# just setting the same uid another time is allowed
handler.setUid(dummy, uid)
result = handler.getUid(dummy)
self.assertEqual(uid, result)
def test_setExistingUidOnDifferentObjectWithCheckRaisesException(self):
handler = self.uidhandler
dummy = self.app.dummy
dummy2 = self.app.dummy2
UniqueIdError = handler.UniqueIdError
# registering and unregisterung a object just to get a free uid
uid1_reg = handler.register(dummy)
handler.register(dummy2)
self.assertRaises(UniqueIdError, handler.setUid, dummy2, uid1_reg)
def test_setExistingUidOnDifferentObjectWithoutCheck(self):
handler = self.uidhandler
dummy = self.app.dummy
dummy2 = self.app.dummy2
UniqueIdError = handler.UniqueIdError
# registering and unregisterung a object just to get a free uid
uid1_reg = handler.register(dummy)
uid2_reg = handler.register(dummy2)
# now lets double the unique id
handler.setUid(dummy2, uid1_reg, check_uniqueness=False)
# calling a getter returns one object and generates a log
# we can't capture. So let's ask the catalog directly.
catalog = self.ctool
result = catalog({handler.UID_ATTRIBUTE_NAME: uid1_reg})
self.assertEqual(len(result), 2)
# dummy2 shall not be reachable anymore by uid2_reg
self.assertRaises(UniqueIdError, handler.getBrain, uid2_reg)
def test_setNoneAsUidRaisesException(self):
handler = self.uidhandler
dummy = self.app.dummy
UniqueIdError = handler.UniqueIdError
handler.register(dummy)
self.assertRaises(UniqueIdError, handler.setUid, dummy, None)
def test_setArbitraryKindOfUidRaisesException(self):
handler = self.uidhandler
dummy = self.app.dummy
handler.register(dummy)
# As we don't know what kind of exception the implementation
# throws lets check for all exceptions!
# IMHO it makes sense here to catch exceptions in general here!
self.assertRaises(Exception, handler.setUid, dummy, DummyUid())
def test_UidCataloging(self):
handler = self.uidhandler
catalog = self.ctool
dummy = self.app.dummy
uid = handler.register(dummy)
brains = catalog(cmf_uid=uid)
self.assertEqual(len(brains), 1)
def test_UidCatalogingDoesNotAcquireUid(self):
handler = self.uidhandler
catalog = self.ctool
self.app._setObject('folder', DummyFolder('folder'))
folder = self.app.folder
uid = handler.register(folder)
brains = catalog(cmf_uid=uid)
self.assertEqual(len(brains), 1)
# Now catalog an unregistered subobject of the folder.
# It should not acquire the cmf_uid, obviously.
folder._setObject('dummy', DummyContent(id='dummy'))
folder.dummy.indexObject()
brains = catalog(cmf_uid=uid)
self.assertEqual(len(brains), 1)
def test_UidCatalogingDoesNotCatalogPortalRoot(self):
handler = self.uidhandler
catalog = self.ctool
dummy = self.app.dummy
# mock the portal root, which has empty indexing attributes
dummy.reindexObject = lambda: None
uid = handler.register(dummy)
brains = catalog(cmf_uid=uid)
self.assertEqual(len(brains), 0)
def _initSite(self, foo=2):
site = Folder(id='site').__of__(self.app)
ctool = CatalogTool()
getSiteManager().registerUtility(ctool, ICatalogTool)
for obj_id in ctool.objectIds():
ctool._delObject(obj_id)
for idx_id in ctool.indexes():
ctool.delIndex(idx_id)
for col in ctool.schema()[:]:
ctool.delColumn(col)
if foo > 0:
ctool._setObject('foo_plexicon', PLexicon('foo_plexicon'))
lex = ctool.foo_plexicon
lex._pipeline = (Splitter(), CaseNormalizer(), StopWordRemover())
extra = _extra()
extra.lexicon_id = 'foo_plexicon'
extra.index_type = 'Okapi BM25 Rank'
ctool.addIndex('foo_zctext', 'ZCTextIndex', extra)
ctool.addColumn('foo_zctext')
return site, ctool
def test_search_restrict_visible(self):
catalog = CatalogTool()
now = DateTime()
dummy = DummyContent(catalog=1)
dummy._View_Permission = ('Blob',)
self.loginWithRoles('Blob')
# visible
dummy.effective = now-2
dummy.expires = now+2
catalog.catalog_object(dummy, '/dummy')
self.assertEqual(1, len(catalog._catalog.searchResults()))
self.assertEqual(1, len(catalog.searchResults()))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': now-1, 'range': 'min'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': now-1, 'range': 'max'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': now+1, 'range': 'min'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': now+1, 'range': 'max'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': (now-1, now+1), 'range': 'min:max'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': (now-1, now+1), 'range': 'minmax'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-2, 'range': None})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': now-3, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': now-3, 'range': 'max'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': now+3, 'range': 'min'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': now+3, 'range': 'max'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': (now-3, now+3), 'range': 'min:max'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': (now-3, now+3), 'range': 'minmax'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-1, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now-1, 'range': 'max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now+1, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now+1, 'range': 'max'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': (now-1, now+1), 'range': 'min:max'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': (now-1, now+1), 'range': 'minmax'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now-3, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now-3, 'range': 'max'})))
self.assertEqual(0, len(catalog.searchResults(
expires={'query': now+3, 'range': 'min'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': now+3, 'range': 'max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': (now-3, now+3), 'range': 'min:max'})))
self.assertEqual(1, len(catalog.searchResults(
expires={'query': (now-3, now+3), 'range': 'minmax'})))
self.assertEqual(1, len(catalog.searchResults(
effective={'query': now-1, 'range': 'max'},
expires={'query': now+1, 'range': 'min'})))
self.assertEqual(0, len(catalog.searchResults(
effective={'query': now+1, 'range': 'max'},
expires={'query': now+3, 'range': 'min'})))
def __init__(self):
CatalogTool.__init__(self)
def uncatalog_object(self, *args, **kwargs):
self._increment_counter()
return BaseTool.uncatalog_object(self, *args, **kwargs)
