def test_DateIndex(self):
from xml.dom.minidom import parseString
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
from Products.GenericSetup.testing import DummySetupEnviron
from Products.GenericSetup.PluginIndexes.exportimport \
import DateIndexNodeAdapter
environ = DummySetupEnviron()
def _no_clear(*a):
raise AssertionError("Don't clear me!")
index = DateIndex('foo_date')
index._setPropValue('index_naive_time_as_local', True)
index.clear = _no_clear
adapted = DateIndexNodeAdapter(index, environ)
adapted.node = parseString(_DATE_XML).documentElement # no raise
def test_DateIndex(self):
from xml.dom.minidom import parseString
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
from Products.GenericSetup.testing import DummySetupEnviron
from Products.GenericSetup.PluginIndexes.exportimport \
import DateIndexNodeAdapter
environ = DummySetupEnviron()
def _no_clear(*a):
raise AssertionError("Don't clear me!")
index = DateIndex('foo_date')
index._setPropValue('index_naive_time_as_local', True)
index.clear = _no_clear
adapted = DateIndexNodeAdapter(index, environ)
adapted.node = parseString(_DATE_XML).documentElement # no raise
def setUp(self):
self._values = (
(0, Dummy('a', None)), # None
(1, Dummy('b', DateTime(0))), # 1055335680
(2, Dummy('c', DateTime('2002-05-08 15:16:17'))), # 1072667236
(3, Dummy('d', DateTime('2032-05-08 15:16:17'))), # 1088737636
(4, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(5, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(6, Dummy('f', 1072742620.0)), # 1073545923
(7, Dummy('f', 1072742900)), # 1073545928
(8, Dummy('g', date(2034,2,5))), # 1073599200
(9, Dummy('h', datetime(2034,2,5,15,20,5))), # (varies)
(10, Dummy('i', datetime(2034,2,5,10,17,5,
tzinfo=Eastern))), # 1073600117
)
self._index = DateIndex('date')
self._noop_req = {'bar': 123}
self._request = {'date': DateTime(0)}
self._min_req = {'date': {'query': DateTime('2032-05-08 15:16:17'),
'range': 'min'}}
self._max_req = {'date': {'query': DateTime('2032-05-08 15:16:17'),
'range': 'max'}}
self._range_req = {'date': {'query':(DateTime('2002-05-08 15:16:17'),
DateTime('2062-05-08 15:16:17')),
'range': 'min:max'}}
self._zero_req = {'date': 0}
self._none_req = {'date': None}
self._float_req = {'date': 1072742620.0}
self._int_req = {'date': 1072742900}
class DateIndexNodeAdapterTests(NodeAdapterTestCase, unittest.TestCase):
layer = ExportImportZCMLLayer
def _getTargetClass(self):
from ..exportimport import DateIndexNodeAdapter
return DateIndexNodeAdapter
def setUp(self):
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
self._obj = DateIndex('foo_date')
self._obj._setPropValue('precision', 0)
self._XML = _DATE_XML
def _verifyImport(self, obj):
self.assertEqual(obj.id, 'foo_date')
def setUp(self):
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
PlacelessSetup.setUp(self)
zcml.load_config('meta.zcml', Products.Five)
zcml.load_config('configure.zcml', Products.GenericSetup.PluginIndexes)
self._obj = DateIndex('foo_date')
self._XML = _DATE_XML
def setUp(self):
import Products.GenericSetup.PluginIndexes
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
NodeAdapterTestCase.setUp(self)
zcml.load_config('configure.zcml', Products.GenericSetup.PluginIndexes)
self._obj = DateIndex('foo_date')
self._XML = _DATE_XML
def recreateCatalog(self, zcm, lang):
#-- Create catalog
cat_id = 'catalog_%s' % lang
root = self.getRootElement()
if cat_id in root.objectIds():
root.manage_delObjects([cat_id])
cat_title = 'Default catalog'
zcatalog = ZCatalog.ZCatalog(id=cat_id, title=cat_title, container=root)
root._setObject(zcatalog.id, zcatalog)
zcatalog = getZCatalog(self, lang)
writeChangesLog(
zcatalog, '[recreateCatalog]: ' +
self.getZMILangStr('MSG_INSERTED') % zcatalog.meta_type)
#-- Add lexicon
addLexicon(self, zcatalog)
#-- Add columns
for index_name in ['id', 'meta_id'
] + ['zcat_column_%s' % x for x in extra_column_ids]:
zcatalog.manage_addColumn(index_name)
#-- Add Indexes (incl. Columns)
for attr_id in zcm._getAttrIds():
attr_type = 'string'
for meta_id in self.getMetaobjIds():
meta_obj_attr = self.getMetaobjAttr(meta_id, attr_id)
if meta_obj_attr:
attr_type = meta_obj_attr['type']
break
index_name = 'zcat_index_%s' % attr_id
index_type = zcm.getConfProperty('ZCatalog.TextIndexType',
'ZCTextIndex')
if attr_id == 'home_id':
index_type = KeywordIndex(attr_id)
elif attr_type == 'date':
index_type = DateIndex(attr_id)
extra = None
if index_type == 'ZCTextIndex':
extra = Empty()
extra.doc_attr = index_name
extra.index_type = 'Okapi BM25 Rank'
extra.lexicon_id = 'Lexicon'
elif index_type != 'KeywordIndex':
extra = {}
extra['default_encoding'] = 'utf-8'
extra['indexed_fields'] = index_name
extra['fields'] = [index_name]
extra['near_distance'] = 5
extra['splitter_casefolding'] = 1
extra['splitter_max_len'] = 64
extra['splitter_separators'] = '.+-_@'
extra['splitter_single_chars'] = 0
zcatalog.manage_addColumn(index_name)
zcatalog.manage_addIndex(index_name, index_type, extra)
def setUp(self):
self._values = (
(0, Dummy('a', None)), # None
(1, Dummy('b', DateTime(0))), # 1055335680
(2, Dummy('c', DateTime('2002-05-08 15:16:17'))), # 1072667236
(3, Dummy('d', DateTime('2032-05-08 15:16:17'))), # 1088737636
(4, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(5, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(6, Dummy('f', 1072742620.0)), # 1073545923
(7, Dummy('f', 1072742900)), # 1073545928
(8, Dummy('g', date(2034, 2, 5))), # 1073599200
(9, Dummy('h', datetime(2034, 2, 5, 15, 20, 5))), # (varies)
(10, Dummy('i', datetime(2034, 2, 5, 10, 17, 5,
tzinfo=Eastern))), # 1073600117
)
self._index = DateIndex('date')
self._noop_req = {'bar': 123}
self._request = {'date': DateTime(0)}
self._min_req = {
'date': {
'query': DateTime('2032-05-08 15:16:17'),
'range': 'min'
}
}
self._max_req = {
'date': {
'query': DateTime('2032-05-08 15:16:17'),
'range': 'max'
}
}
self._range_req = {
'date': {
'query': (DateTime('2002-05-08 15:16:17'),
DateTime('2062-05-08 15:16:17')),
'range':
'min:max'
}
}
self._zero_req = {'date': 0}
self._none_req = {'date': None}
self._float_req = {'date': 1072742620.0}
self._int_req = {'date': 1072742900}
def getCatalog(self):
try:
return self._getOb(CATALOG_NAME)
except AttributeError:
from Products.ZCatalog.ZCatalog import manage_addZCatalog
# Make catalog for Devices
manage_addZCatalog(self, CATALOG_NAME, CATALOG_NAME)
zcat = self._getOb(CATALOG_NAME)
cat = zcat._catalog
for idxname in ['status', 'type', 'user']:
cat.addIndex(idxname, makeCaseInsensitiveFieldIndex(idxname))
for idxname in ['scheduled', 'started', 'finished']:
cat.addIndex(idxname, DateIndex(idxname))
return zcat
def testMeetingValues(self):
brain = api.content.find(context=self.meeting, portal_type="Item")[0]
indexes = self.catalog.getIndexDataForRID(brain.getRID())
# indexed item number is a sortable integer
self.assertEqual(self.item.number, "1")
self.assertEqual(self.item.sortable_number, 100)
self.assertEqual(indexes.get("sortable_number"), 100)
self.assertEqual(indexes.get("number"), "1")
self.assertEqual(self.meeting.title, indexes.get("linkedMeetingTitle"))
self.assertEqual(self.meeting.UID(), indexes.get("linkedMeetingUID"))
self.assertEqual(
indexes.get("linkedMeetingDate"),
DateIndex("test")._convert(
datetime(2018, 12, 20, 18, 25, 43, 51100)),
)
self.assertEqual(str(self.meeting.date_time.year), indexes.get("year"))
def setUp(self):
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
self._obj = DateIndex('foo_date')
self._XML = _DATE_XML
class DI_Tests(unittest.TestCase):
def setUp(self):
self._values = (
(0, Dummy('a', None)), # None
(1, Dummy('b', DateTime(0))), # 1055335680
(2, Dummy('c', DateTime('2002-05-08 15:16:17'))), # 1072667236
(3, Dummy('d', DateTime('2032-05-08 15:16:17'))), # 1088737636
(4, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(5, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(6, Dummy('f', 1072742620.0)), # 1073545923
(7, Dummy('f', 1072742900)), # 1073545928
(8, Dummy('g', date(2034,2,5))), # 1073599200
(9, Dummy('h', datetime(2034,2,5,15,20,5))), # (varies)
(10, Dummy('i', datetime(2034,2,5,10,17,5,
tzinfo=Eastern))), # 1073600117
)
self._index = DateIndex('date')
self._noop_req = {'bar': 123}
self._request = {'date': DateTime(0)}
self._min_req = {'date': {'query': DateTime('2032-05-08 15:16:17'),
'range': 'min'}}
self._max_req = {'date': {'query': DateTime('2032-05-08 15:16:17'),
'range': 'max'}}
self._range_req = {'date': {'query':(DateTime('2002-05-08 15:16:17'),
DateTime('2062-05-08 15:16:17')),
'range': 'min:max'}}
self._zero_req = {'date': 0}
self._none_req = {'date': None}
self._float_req = {'date': 1072742620.0}
self._int_req = {'date': 1072742900}
def _populateIndex( self ):
for k, v in self._values:
self._index.index_object(k, v)
def _checkApply(self, req, expectedValues):
result, used = self._index._apply_index(req)
if hasattr(result, 'keys'):
result = result.keys()
self.failUnlessEqual(used, ('date',))
self.failUnlessEqual(len(result), len(expectedValues),
'%s | %s' % (result, expectedValues))
for k, v in expectedValues:
self.failUnless(k in result)
def _convert(self, dt):
if type(dt) in (FloatType, IntType):
yr, mo, dy, hr, mn = time.gmtime(dt)[:5]
elif type(dt) is date:
yr, mo, dy, hr, mn = dt.timetuple()[:5]
elif type(dt) is datetime:
if dt.tzinfo is None: # default behavior of index
dt = dt.replace(tzinfo=Local)
yr, mo, dy, hr, mn = dt.utctimetuple()[:5]
else:
yr, mo, dy, hr, mn = dt.toZone('UTC').parts()[:5]
return (((yr * 12 + mo) * 31 + dy) * 24 + hr) * 60 + mn
def test_z3interfaces(self):
from Products.PluginIndexes.interfaces import IDateIndex
from Products.PluginIndexes.interfaces import IPluggableIndex
from Products.PluginIndexes.interfaces import ISortIndex
from Products.PluginIndexes.interfaces import IUniqueValueIndex
from zope.interface.verify import verifyClass
verifyClass(IDateIndex, DateIndex)
verifyClass(IPluggableIndex, DateIndex)
verifyClass(ISortIndex, DateIndex)
verifyClass(IUniqueValueIndex, DateIndex)
def test_empty(self):
empty = self._index
self.failUnlessEqual(len(empty), 0)
self.failUnlessEqual(len(empty.referencedObjects()), 0)
self.failUnless(empty.getEntryForObject(1234) is None)
marker = []
self.failUnless(empty.getEntryForObject(1234, marker) is marker)
empty.unindex_object(1234) # shouldn't throw
self.failUnless(empty.hasUniqueValuesFor('date'))
self.failIf(empty.hasUniqueValuesFor('foo'))
self.failUnlessEqual(len(empty.uniqueValues('date')), 0)
self.failUnless(empty._apply_index({'zed': 12345}) is None)
self._checkApply(self._request, [])
self._checkApply(self._min_req, [])
self._checkApply(self._max_req, [])
self._checkApply(self._range_req, [])
def test_retrieval( self ):
self._populateIndex()
values = self._values
index = self._index
self.failUnlessEqual(len(index), len(values) - 2) # One dupe, one empty
self.failUnlessEqual(len(index.referencedObjects()), len(values) - 1)
# One empty
self.failUnless(index.getEntryForObject(1234) is None)
marker = []
self.failUnless(index.getEntryForObject(1234, marker) is marker)
index.unindex_object(1234) # shouldn't throw
for k, v in values:
if v.date():
self.failUnlessEqual(self._index.getEntryForObject(k),
self._convert(v.date()))
self.failUnlessEqual(len(index.uniqueValues('date')), len(values) - 2)
self.failUnless(index._apply_index(self._noop_req) is None)
self._checkApply(self._request, values[1:2])
self._checkApply(self._min_req, values[3:6] + values[8:])
self._checkApply(self._max_req, values[1:4] + values[6:8])
self._checkApply(self._range_req, values[2:] )
self._checkApply(self._float_req, [values[6]] )
self._checkApply(self._int_req, [values[7]] )
def test_naive_convert_to_utc(self):
values = self._values
index = self._index
index.index_naive_time_as_local = False
self._populateIndex()
for k, v in values[9:]:
# assert that the timezone is effectively UTC for item 9,
# and still correct for item 10
yr, mo, dy, hr, mn = v.date().utctimetuple()[:5]
val = (((yr * 12 + mo) * 31 + dy) * 24 + hr) * 60 + mn
self.failUnlessEqual(self._index.getEntryForObject(k), val)
def test_removal(self):
""" DateIndex would hand back spurious entries when used as a
sort_index, because it previously was not removing entries
from the _unindex when indexing an object with a value of
None. The catalog consults a sort_index's
documentToKeyMap() to build the brains.
"""
values = self._values
index = self._index
self._populateIndex()
self._checkApply(self._int_req, [values[7]])
index.index_object(7, None)
self.failIf(7 in index.documentToKeyMap().keys())
def setUp(self):
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
self._obj = DateIndex('foo_date')
self._obj._setPropValue('precision', 0)
self._XML = _DATE_XML
def setUp(self):
from Products.PluginIndexes.DateIndex.DateIndex import DateIndex
NodeAdapterTestCase.setUp(self)
self._obj = DateIndex('foo_date')
self._XML = _DATE_XML
class DI_Tests(unittest.TestCase):
def setUp(self):
self._values = (
(0, Dummy('a', None)), # None
(1, Dummy('b', DateTime(0))), # 1055335680
(2, Dummy('c', DateTime('2002-05-08 15:16:17'))), # 1072667236
(3, Dummy('d', DateTime('2032-05-08 15:16:17'))), # 1088737636
(4, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(5, Dummy('e', DateTime('2062-05-08 15:16:17'))), # 1018883325
(6, Dummy('f', 1072742620.0)), # 1073545923
(7, Dummy('f', 1072742900)), # 1073545928
(8, Dummy('g', date(2034, 2, 5))), # 1073599200
(9, Dummy('h', datetime(2034, 2, 5, 15, 20, 5))), # (varies)
(10, Dummy('i', datetime(2034, 2, 5, 10, 17, 5,
tzinfo=Eastern))), # 1073600117
)
self._index = DateIndex('date')
self._noop_req = {'bar': 123}
self._request = {'date': DateTime(0)}
self._min_req = {
'date': {
'query': DateTime('2032-05-08 15:16:17'),
'range': 'min'
}
}
self._max_req = {
'date': {
'query': DateTime('2032-05-08 15:16:17'),
'range': 'max'
}
}
self._range_req = {
'date': {
'query': (DateTime('2002-05-08 15:16:17'),
DateTime('2062-05-08 15:16:17')),
'range':
'min:max'
}
}
self._zero_req = {'date': 0}
self._none_req = {'date': None}
self._float_req = {'date': 1072742620.0}
self._int_req = {'date': 1072742900}
def _populateIndex(self):
for k, v in self._values:
self._index.index_object(k, v)
def _checkApply(self, req, expectedValues):
result, used = self._index._apply_index(req)
if hasattr(result, 'keys'):
result = result.keys()
self.failUnlessEqual(used, ('date', ))
self.failUnlessEqual(len(result), len(expectedValues),
'%s | %s' % (result, expectedValues))
for k, v in expectedValues:
self.failUnless(k in result)
def _convert(self, dt):
if type(dt) in (FloatType, IntType):
yr, mo, dy, hr, mn = time.gmtime(dt)[:5]
elif type(dt) is date:
yr, mo, dy, hr, mn = dt.timetuple()[:5]
elif type(dt) is datetime:
if dt.tzinfo is None: # default behavior of index
dt = dt.replace(tzinfo=Local)
yr, mo, dy, hr, mn = dt.utctimetuple()[:5]
else:
yr, mo, dy, hr, mn = dt.toZone('UTC').parts()[:5]
return (((yr * 12 + mo) * 31 + dy) * 24 + hr) * 60 + mn
def test_z3interfaces(self):
from Products.PluginIndexes.interfaces import IDateIndex
from Products.PluginIndexes.interfaces import IPluggableIndex
from Products.PluginIndexes.interfaces import ISortIndex
from Products.PluginIndexes.interfaces import IUniqueValueIndex
from zope.interface.verify import verifyClass
verifyClass(IDateIndex, DateIndex)
verifyClass(IPluggableIndex, DateIndex)
verifyClass(ISortIndex, DateIndex)
verifyClass(IUniqueValueIndex, DateIndex)
def test_empty(self):
empty = self._index
self.failUnlessEqual(len(empty), 0)
self.failUnlessEqual(len(empty.referencedObjects()), 0)
self.failUnless(empty.getEntryForObject(1234) is None)
marker = []
self.failUnless(empty.getEntryForObject(1234, marker) is marker)
empty.unindex_object(1234) # shouldn't throw
self.failUnless(empty.hasUniqueValuesFor('date'))
self.failIf(empty.hasUniqueValuesFor('foo'))
self.failUnlessEqual(len(empty.uniqueValues('date')), 0)
self.failUnless(empty._apply_index({'zed': 12345}) is None)
self._checkApply(self._request, [])
self._checkApply(self._min_req, [])
self._checkApply(self._max_req, [])
self._checkApply(self._range_req, [])
def test_retrieval(self):
self._populateIndex()
values = self._values
index = self._index
self.failUnlessEqual(len(index),
len(values) - 2) # One dupe, one empty
self.failUnlessEqual(len(index.referencedObjects()), len(values) - 1)
# One empty
self.failUnless(index.getEntryForObject(1234) is None)
marker = []
self.failUnless(index.getEntryForObject(1234, marker) is marker)
index.unindex_object(1234) # shouldn't throw
for k, v in values:
if v.date():
self.failUnlessEqual(self._index.getEntryForObject(k),
self._convert(v.date()))
self.failUnlessEqual(len(index.uniqueValues('date')), len(values) - 2)
self.failUnless(index._apply_index(self._noop_req) is None)
self._checkApply(self._request, values[1:2])
self._checkApply(self._min_req, values[3:6] + values[8:])
self._checkApply(self._max_req, values[1:4] + values[6:8])
self._checkApply(self._range_req, values[2:])
self._checkApply(self._float_req, [values[6]])
self._checkApply(self._int_req, [values[7]])
def test_naive_convert_to_utc(self):
values = self._values
index = self._index
index.index_naive_time_as_local = False
self._populateIndex()
for k, v in values[9:]:
# assert that the timezone is effectively UTC for item 9,
# and still correct for item 10
yr, mo, dy, hr, mn = v.date().utctimetuple()[:5]
val = (((yr * 12 + mo) * 31 + dy) * 24 + hr) * 60 + mn
self.failUnlessEqual(self._index.getEntryForObject(k), val)
def test_removal(self):
""" DateIndex would hand back spurious entries when used as a
sort_index, because it previously was not removing entries
from the _unindex when indexing an object with a value of
None. The catalog consults a sort_index's
documentToKeyMap() to build the brains.
"""
values = self._values
index = self._index
self._populateIndex()
self._checkApply(self._int_req, [values[7]])
index.index_object(7, None)
self.failIf(7 in index.documentToKeyMap().keys())
