def test__currentUser(self):
# Anonymous user
u = MockUser()
pm = MockPortal_membership(user=u)
context = MockSite(portal_membership=pm)
data = Row(
index='Creator',
operator='_currentUser',
values=None
)
parsed = queryparser._currentUser(context, data)
expected = {'Creator': {'query': 'Anonymous User'}}
self.assertEqual(parsed, expected)
# Logged in user 'admin'
u = MockUser(username='******')
pm = MockPortal_membership(user=u)
context = MockSite(portal_membership=pm)
data = Row(
index='Creator',
operator='_currentUser',
values=None
)
parsed = queryparser._currentUser(context, data)
expected = {'Creator': {'query': 'admin'}}
self.assertEqual(parsed, expected)
def test__intEqual(self):
data = Row(index='modified', operator='_intEqual', values='20')
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': 20}}
self.assertEqual(parsed, expected)
data = Row(index='modified', operator='_intEqual', values=['20', '21'])
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': [20, 21]}}
self.assertEqual(parsed, expected)
def test__path(self):
# normal path
data = Row(index='path', operator='_path', values='/news/')
parsed = queryparser._path(MockSite(), data)
expected = {'path': {'query': ['/%s/news/' % MOCK_SITE_ID]}}
self.assertEqual(parsed, expected)
# by uid
data = Row(index='path', operator='_path', values='00000000000000001')
parsed = queryparser._path(MockSite(), data)
expected = {'path': {'query': ['/%s/foo' % MOCK_SITE_ID]}}
self.assertEqual(parsed, expected)
def test__equal(self):
data = Row(index='modified', operator='_equal', values='2010/03/18')
parsed = queryparser._equal(MockSite(), data)
expected = {'modified': {'query': '2010/03/18'}}
self.assertEqual(parsed, expected)
data = Row(index='modified',
operator='_equal',
values=['2010/03/18', '2010/03/19'])
parsed = queryparser._equal(MockSite(), data)
expected = {'modified': {'query': ['2010/03/18', '2010/03/19']}}
self.assertEqual(parsed, expected)
def test__path(self):
# absoute path from plone site root
data = Row(index='path', operator='_path', values='/news/')
parsed = queryparser._absolutePath(MockSite(), data)
expected = {'path': {'query': ['/%s/news/' % MOCK_SITE_ID]}}
self.assertEqual(parsed, expected)
# by uid
data = Row(index='path', operator='_path', values='00000000000000001')
parsed = queryparser._absolutePath(MockSite(), data)
expected = {'path': {'query': ['/%s/foo' % MOCK_SITE_ID]}}
self.assertEqual(parsed, expected)
def test__relativePath(self):
# build test navtree
context = MockObject(uid='00000000000000001',
path="/%s/bar/fizz" % MOCK_SITE_ID)
context.__parent__ = MockObject(uid='00000000000000002',
path="/%s/bar" % MOCK_SITE_ID)
# Plone root
context.__parent__.__parent__ = MockSite()
# Zope root
context.__parent__.__parent__.__parent__ = \
MockObject(uid='00000000000000004', path="/")
# ploneroot sub folder
context.__parent__.__parent__.ham = \
MockObject(uid='00000000000000005',
path="/%s/ham" % MOCK_SITE_ID)
# collection subfolder
context.__parent__.egg = MockObject(uid='00000000000000006',
path="/%s/bar/egg" % MOCK_SITE_ID)
# show my siblings
data = Row(index='path', operator='_relativePath', values='..')
parsed = queryparser._relativePath(context, data)
expected = {'path': {'query': '/%s/bar' % MOCK_SITE_ID}}
self.assertEqual(parsed, expected)
# walk upwards
data = Row(index='path', operator='_relativePath', values='../../')
parsed = queryparser._relativePath(context, data)
expected = {'path': {'query': '/%s' % MOCK_SITE_ID}}
self.assertEqual(parsed, expected)
# if you walk beyond INavigatinRoot it should stop and return
data = Row(index='path', operator='_relativePath', values='../../../')
parsed = queryparser._relativePath(context, data)
expected = {'path': {'query': '/%s' % MOCK_SITE_ID}}
self.assertEqual(parsed, expected)
# reach a subfolder on Plone root
data = Row(index='path', operator='_relativePath', values='../../ham')
parsed = queryparser._relativePath(context, data)
expected = {'path': {'query': '/%s/ham' % MOCK_SITE_ID}}
self.assertEqual(parsed, expected)
# reach a subfolder on parent of collection
data = Row(index='path', operator='_relativePath', values='../egg')
parsed = queryparser._relativePath(context, data)
expected = {'path': {'query': '/%s/bar/egg' % MOCK_SITE_ID}}
self.assertEqual(parsed, expected)
def test__today(self):
now = DateTime()
expected_dates = [now.earliestTime(), now.latestTime()]
expected = {'modified': {'query': expected_dates, 'range': 'minmax'}}
data = Row(index='modified', operator='_today', values=expected_dates)
parsed = queryparser._today(MockSite(), data)
self.assertEqual(parsed, expected)
def test__largerThan(self):
data = Row(index='modified',
operator='_largerThan',
values='2010/03/18')
parsed = queryparser._largerThan(MockSite(), data)
expected = {'modified': {'query': '2010/03/18', 'range': 'min'}}
self.assertEqual(parsed, expected)
def test__intLargerThan(self):
# bytes
data = Row(index='modified', operator='_intLargerThan', values=b'20')
parsed = queryparser._intLargerThan(MockSite(), data)
expected = {'modified': {'query': 20, 'range': 'min'}}
self.assertEqual(parsed, expected)
# text
data = Row(index='modified', operator='_intLargerThan', values=u'20')
parsed = queryparser._intLargerThan(MockSite(), data)
expected = {'modified': {'query': 20, 'range': 'min'}}
self.assertEqual(parsed, expected)
# bad value
data = Row(index='modified', operator='_intLargerThan', values='bad')
parsed = queryparser._intLargerThan(MockSite(), data)
expected = {'modified': {'query': None, 'range': 'min'}}
self.assertEqual(parsed, expected)
def test__intLessThan(self):
data = Row(
index='modified',
operator='_intLessThan',
values='20'
)
parsed = queryparser._intLessThan(MockSite(), data)
expected = {'modified': {'query': 20, 'range': 'max'}}
self.assertEqual(parsed, expected)
def test__between_reversed_dates(self):
data = Row(
index='modified',
operator='_between',
values=['2009/08/14', '2009/08/12']
)
parsed = queryparser._between(MockSite(), data)
expected = {'modified': {'query': ['2009/08/12', '2009/08/14'],
'range': 'minmax'}}
self.assertEqual(parsed, expected)
def test__afterRelativeDate(self):
days = 2
now = DateTime()
mydate = now.earliestTime() + days
expected = {'effective': {'query': mydate, 'range': 'min'}}
data = Row(index='effective',
operator='_afterRelativeDate',
values=days)
parsed = queryparser._afterRelativeDate(MockSite(), data)
self.assertEqual(parsed, expected)
def test__beforeRelativeDate(self):
days = 365
now = DateTime()
mydate = now.earliestTime() - days
expected = {'modified': {'query': mydate, 'range': 'max'}}
data = Row(index='modified',
operator='_beforeRelativeDate',
values=days)
parsed = queryparser._beforeRelativeDate(MockSite(), data)
self.assertEqual(parsed, expected)
def test__moreThanRelativeDate(self):
days = 2
now = DateTime()
mydate = now - days
expected_dates = [mydate.earliestTime(), now.latestTime()]
expected = {'modified': {'query': expected_dates, 'range': 'minmax'}}
data = Row(index='modified',
operator='_moreThanRelativeDate',
values=days)
parsed = queryparser._moreThanRelativeDate(MockSite(), data)
self.assertEqual(parsed, expected)
def test_objStartsWithSiteId(self):
data = Row(index='path',
operator='_path',
values='/{0}-news/'.format(MOCK_SITE_ID))
parsed = queryparser._absolutePath(MockSite(), data)
expected = {
'path': {
'query': ['/{0}/{1}-news/'.format(MOCK_SITE_ID, MOCK_SITE_ID)]
}
}
self.assertEqual(parsed, expected)
def test__showInactive(self):
# Anonymous user
u = MockUser()
pm = MockPortal_membership(user=u)
context = MockSite(portal_membership=pm)
data = Row(index='show_inactive',
operator='_showInactive',
values=["Manager"])
parsed = queryparser._showInactive(context, data)
# False is expected since Anonymous doesn't have Manager role
expected = {'show_inactive': False}
self.assertEqual(parsed, expected)
# Logged in user 'admin'
u = MockUser(username='******', roles=("Manager",))
pm = MockPortal_membership(user=u)
context = MockSite(portal_membership=pm)
data = Row(index='show_inactive',
operator='_showInactive',
values=["Manager"])
parsed = queryparser._showInactive(context, data)
# True is expected since Admin should have Manager role
expected = {'show_inactive': True}
self.assertEqual(parsed, expected)
def test__navigationPath(self):
# absoute path from plone site root
# Search base
context = MockObject(uid='00000000000000001',
path="/%s/foo/bar" % MOCK_SITE_ID)
# Nav root
context.__parent__ = MockNavRoot(uid='00000000000000002',
path="/%s/foo" % MOCK_SITE_ID)
# Plone root
context.__parent__.__parent__ = MockSite()
# Zope root
context.__parent__.__parent__.__parent__ = \
MockObject(uid='00000000000000004', path="/")
data = Row(index='path', operator='_navigationPath', values='/bar/')
parsed = queryparser._navigationPath(context, data)
expected = {'path': {'query': ['/%s/foo/bar/' % MOCK_SITE_ID]}}
self.assertEqual(parsed, expected)
def test__intEqual(self):
# bytes
data = Row(index='modified', operator='_intEqual', values=b'20')
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': 20}}
self.assertEqual(parsed, expected)
# list of bytes
data = Row(index='modified',
operator='_intEqual',
values=[b'20', b'21'])
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': [20, 21]}}
self.assertEqual(parsed, expected)
# text
data = Row(index='modified', operator='_intEqual', values=u'20')
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': 20}}
self.assertEqual(parsed, expected)
# list of texts
data = Row(index='modified',
operator='_intEqual',
values=[u'20', u'21'])
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': [20, 21]}}
self.assertEqual(parsed, expected)
# bad text
data = Row(index='modified', operator='_intEqual', values='bad')
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': None}}
self.assertEqual(parsed, expected)
# list of bad text
data = Row(index='modified',
operator='_intEqual',
values=[b'bad', 'text', u'values'])
parsed = queryparser._intEqual(MockSite(), data)
expected = {'modified': {'query': None}}
self.assertEqual(parsed, expected)
def test__between_empty_input(self):
data = Row(index='modified', operator='_between', values='')
parsed = queryparser._between(MockSite(), data)
expected = {'modified': {'query': ['', ''], 'range': 'minmax'}}
self.assertEqual(parsed, expected)
def _this_month(context, row):
now = DateTime()
row = Row(index=row.index,
operator=row.operator,
values=getBounds(now, 'this_month'))
return _between(context, row)