def test_composite_and_missing_in_db(self):
"""
Pass through branches of a CompositeAndFilter not indexed by the data
source.
"""
self.maxDiff = 10000
result = adorn_filter(
None, self.ds,
ContactsFilter(
locations=CompositeAndFilter({
'city': MatchFilter('indy'),
'state': MatchFilter('IN'),
'county': MatchFilter('marion'),
})))
self.assertEqual([{
'locations': {
'city': ['indy'],
'state': ['IN'],
'county': ['marion'],
},
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(locations=CompositeAndFilter(
{
'city': MatchFilter({
'value': 'indy',
'display': 'Indy'
}),
'state': MatchFilter({
'value': 'IN',
'display': 'Indiana'
}),
'county': MatchFilter('marion'),
})), result)
def test_or_group(self):
"""Test adorning an OrGroupFilter."""
self.maxDiff = 10000
result = adorn_filter(
None, self.ds,
ContactsFilter(tags=OrGroupFilter([
MatchFilter('a'),
MatchFilter('b'),
MatchFilter('c'),
])))
self.assertEqual([{
'tags': ['a', 'b', 'c'],
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(tags=OrGroupFilter([
MatchFilter({
'value': 'a',
'display': 'A',
'hexcolor': 'aaaaaa'
}),
MatchFilter({
'value': 'b',
'display': 'B',
'hexcolor': 'bbbbbb'
}),
MatchFilter('c'),
])), result)
def test_composite_and(self):
"""Test adorning a CompositeAndFilter."""
self.maxDiff = 10000
result = adorn_filter(
None, self.ds,
ContactsFilter(
locations=CompositeAndFilter({
'city': MatchFilter('indy'),
'state': MatchFilter('IN'),
})))
self.assertEqual([{
'locations': {
'city': ['indy'],
'state': ['IN'],
},
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(locations=CompositeAndFilter(
{
'city': MatchFilter({
'value': 'indy',
'display': 'Indy'
}),
'state': MatchFilter({
'value': 'IN',
'display': 'Indiana'
}),
})), result)
def test_filter_by_tags_and(self):
"""
Show only contact with correct tags in 'and' configuration.
"""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(tags=AndGroupFilter([
OrGroupFilter([MatchFilter('EaSt')]),
OrGroupFilter([MatchFilter('wEsT')])
])), [])
names = {r['name'] for r in recs}
expected = set()
self.assertEqual(expected, names)
# Now try adding another tag.
self.john.tags.add(self.west_tag)
recs = ds.run_unaggregated(
self.company,
ContactsFilter(tags=AndGroupFilter([
OrGroupFilter([MatchFilter('EaSt')]),
OrGroupFilter([MatchFilter('wEsT')])
])), [])
names = {r['name'] for r in recs}
expected = {self.john.name}
self.assertEqual(expected, names)
def test_clone_without_partners(self):
locations_filter = CompositeAndFilter({
'city': MatchFilter('A'), 'state': MatchFilter('B')})
filter = ContactsFilter(partner=[1, 2, 3], locations=locations_filter)
expected_without_partners = ContactsFilter(locations=locations_filter)
self.assertEqual(
expected_without_partners,
filter.clone_without_partner())
def test_clone_without_partners(self):
locations_filter = CompositeAndFilter({
'city': MatchFilter('A'),
'state': MatchFilter('B')
})
filter = ContactsFilter(partner=[1, 2, 3], locations=locations_filter)
expected_without_partners = ContactsFilter(locations=locations_filter)
self.assertEqual(expected_without_partners,
filter.clone_without_partner())
def test_passthrough_missing(self):
"""Pass through items not indexed by the data source."""
result = adorn_filter(
None, self.ds,
ContactsFilter(partner=OrGroupFilter(
[MatchFilter(1), MatchFilter(2)])))
self.assertEqual([{
'partner': [1, 2],
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(partner=OrGroupFilter(
[MatchFilter(1), MatchFilter(2)])), result)
def test_run(self):
"""Test that json run calls are plumbed to datasource correctly."""
result = self.driver.run('unaggregated', 'company', '{}', '["zzz"]')
self.assertEqual('aaa', result)
self.assertEqual(
[['run', 'unaggregated', 'company',
ContactsFilter(), ['zzz']]], self.ds.calls)
def test_match(self):
"""Test adorning a bare MatchFilter."""
result = adorn_filter(
None, self.ds,
ContactsFilter(date=MatchFilter('dt'), tags=MatchFilter('a')))
self.assertEqual([{
'date': ['dt'],
'tags': ['a'],
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(date=MatchFilter('dt'),
tags=MatchFilter({
'value': 'a',
'display': 'A',
'hexcolor': 'aaaaaa'
})), result)
def test_date_filters(self):
"""Test that date filters are built properly."""
spec = '{"date": ["09/01/2015", "09/30/2015"]}'
result = self.driver.build_filter(spec)
expected = ContactsFilter(date=DateRangeFilter(
[datetime(2015, 9, 1), datetime(2015, 9, 30)]))
self.assertEquals(expected, result)
def test_plain_filter_or(self):
"""Convert OrGroupFilter to plain object."""
filt = ContactsFilter(partner=OrGroupFilter([
MatchFilter(1),
MatchFilter(2),
]))
self.assertEqual({'partner': [1, 2]}, plain_filter(filt))
def test_city_filter(self):
"""Test that city filter is built properly."""
result = self.driver.build_filter('{"locations": {"city": "Indy"}}')
self.assertEquals(
ContactsFilter(
locations=CompositeAndFilter({'city': MatchFilter('Indy')})),
result)
def test_tag_filter(self):
"""Test that tag filter is built properly."""
result = self.driver.build_filter('{"tags": [[1, 2], [3, 4]]}')
self.assertEquals(
ContactsFilter(tags=AndGroupFilter([
OrGroupFilter([MatchFilter(1), MatchFilter(2)]),
OrGroupFilter([MatchFilter(3), MatchFilter(4)]),
])), result)
def test_plain_filter_unlinked(self):
"""Convert unlinked filter to plain object."""
filt = ContactsFilter(tags=UnlinkedFilter())
self.assertEqual({
'tags': {
'nolink': True
},
}, plain_filter(filt))
def test_empty_list_filters(self):
"""
Test that an empty list is interpreted as no filter.
"""
spec = '{"partner": [], "partner_tags": []}'
result = self.driver.build_filter(spec)
expected = ContactsFilter()
self.assertEquals(expected, result)
def test_help_partner(self):
"""Check partner help works at all."""
ds = ContactsDataSource()
recs = ds.help_partner(self.company, ContactsFilter(), "A")
self.assertEqual([{
'value': self.partner_a.pk,
'display': 'aaa'
}], recs)
def test_clone_without_full(self):
"""Cloning should remove certain fields."""
filter = ContactsFilter(
tags=['C'],
locations=CompositeAndFilter({
'city': MatchFilter('A'),
'state': MatchFilter('B')}))
expected_with_city = ContactsFilter(
tags=['C'],
locations=CompositeAndFilter({
'city': MatchFilter('A')}))
expected_with_state = ContactsFilter(
tags=['C'],
locations=CompositeAndFilter({
'state': MatchFilter('B')}))
self.assertEqual(expected_with_state, filter.clone_without_city())
self.assertEqual(expected_with_city, filter.clone_without_state())
def test_unlinked_filters(self):
"""
Test that we can build an unlinked filter
"""
spec = '{"partner": {"nolink": true}}'
result = self.driver.build_filter(spec)
expected = ContactsFilter(partner=UnlinkedFilter())
self.assertEquals(expected, result)
def test_help_partner_tags(self):
"""
Check partner tags help works at all.
"""
ds = ContactsDataSource()
recs = ds.help_partner_tags(self.company, ContactsFilter(), "t")
actual = {r['value'] for r in recs}
self.assertEqual({'left', 'right'}, actual)
def test_help_city(self):
"""Check city help works and ignores current city filter."""
ds = ContactsDataSource()
recs = ds.help_city(
self.company,
ContactsFilter(locations=CompositeAndFilter(
{'city': MatchFilter('Los Angeles')})), "angel")
actual = {r['value'] for r in recs}
self.assertEqual({'Los Angeles'}, actual)
def test__plain_filter_date_range(self):
"""Convert date range to plain object."""
filt = ContactsFilter(date=DateRangeFilter(
[datetime(2015, 9, 1), datetime(2015, 9, 30)]))
self.assertEqual(
{
'date': [datetime(2015, 9, 1),
datetime(2015, 9, 30)],
}, plain_filter(filt))
def test_help_state(self):
"""Check state help works and ignores current state filter."""
ds = ContactsDataSource()
recs = ds.help_state(
self.company,
ContactsFilter(
locations=CompositeAndFilter({'state': MatchFilter('zz')})),
"i")
actual = {r['value'] for r in recs}
self.assertEqual({'IL', 'IN'}, actual)
def test_filter_by_city(self):
"""Should show only contacts with correct city."""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(locations=CompositeAndFilter(
{'city': MatchFilter('Los Angeles')})), [])
names = [r['name'] for r in recs]
expected = [self.sue.name]
self.assertEqual(expected, names)
def test_run_unfiltered(self):
"""
Make sure we only get data for this user.
"""
ds = ContactsDataSource()
recs = ds.run_unaggregated(self.company, ContactsFilter(), [])
names = {r['name'] for r in recs}
expected = {self.sue.name, self.john.name}
self.assertEqual(expected, names)
def test_filter_by_partners(self):
"""Should filter by partners."""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(
partner=OrGroupFilter([MatchFilter(self.partner_a.pk)])), [])
subjects = {r['name'] for r in recs}
expected = {self.john.name}
self.assertEqual(expected, subjects)
def test_default_filter(self):
"""should produce a populated filter object."""
ds = ContactsDataSource()
default_filter = ds.get_default_filter(None, self.company)
self.assertEquals(datetime.now().year,
default_filter.date.dates[1].year)
# Take out value dated today. Too hard to run through assertEquals.
default_filter.date.dates[1] = None
expected = ContactsFilter(
date=DateRangeFilter([datetime(2014, 1, 1), None]))
self.assertEquals(expected, default_filter)
def test_filter_by_partner_tags_untagged(self):
"""
Check that we can find a record attached to an untagged partner.
"""
self.partner_b.tags.clear()
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company, ContactsFilter(partner_tags=UnlinkedFilter()), [])
subjects = {r['name'] for r in recs}
expected = {self.sue.name}
self.assertEqual(expected, subjects)
def test_filter_untagged(self):
"""
This indicates that the member selected to filter by untagged.
"""
self.sue.tags.clear()
ds = ContactsDataSource()
recs = ds.run_unaggregated(self.company,
ContactsFilter(tags=UnlinkedFilter()), [])
names = {r['name'] for r in recs}
expected = {self.sue.name}
self.assertEqual(expected, names)
def test_filter_by_partner_tags(self):
"""
Test that we can filter by partner tags.
"""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(partner_tags=AndGroupFilter(
[OrGroupFilter([MatchFilter('rigHt')])])), [])
subjects = {r['name'] for r in recs}
expected = {self.sue.name}
self.assertEqual(expected, subjects)
def test_filter_by_date_after(self):
"""
Should show only contact with last_action_time after date.
"""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(
date=DateRangeFilter([datetime(2015, 10, 1), None])), [])
names = {r['name'] for r in recs}
expected = {self.john.name}
self.assertEqual(expected, names)
def test_filter_by_date_before(self):
"""
Should show only contact with last_action_time before date.
"""
ds = ContactsDataSource()
recs = ds.run_unaggregated(
self.company,
ContactsFilter(
date=DateRangeFilter([None, datetime(2015, 9, 30)])), [])
names = {r['name'] for r in recs}
expected = {self.sue.name}
self.assertEqual(expected, names)
def test_passthrough_missing_composite_and(self):
"""
Pass through when all branches of a CompositeAndFilter are not indexed
by the data source.
"""
result = adorn_filter(
None, self.ds,
ContactsFilter(partner=CompositeAndFilter({
'a': MatchFilter(1),
'b': MatchFilter(2)
})))
self.assertEqual([{
'partner': {
'a': [1],
'b': [2]
},
}], self.ds.adorn_calls)
self.assertEqual(
ContactsFilter(partner=CompositeAndFilter({
'a': MatchFilter(1),
'b': MatchFilter(2)
})), result)
def test_clone_without_empty(self):
"""Cloning empty filters shouldn't crash."""
filter = ContactsFilter()
self.assertEqual(ContactsFilter(), filter.clone_without_city())
self.assertEqual(ContactsFilter(), filter.clone_without_state())