def test_filter_by_data_source(self):
"""Check datasource filter works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company, PartnersFilter(data_source=MatchFilter("zap")), [])
names = {r['name'] for r in recs}
expected = {self.partner_a.name}
self.assertEqual(expected, names)
def test_filter_by_uri(self):
"""Check uri filter works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(uri=MatchFilter("http://www.asdf.com/")), [])
names = {r['name'] for r in recs}
expected = {self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_uri(self):
"""Check uri filter works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(uri="http://www.asdf.com/"),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_data_source(self):
"""Check datasource filter works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(data_source="zap"),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_a.name}
self.assertEqual(expected, names)
def test_filter_by_tags_or(self):
"""Show only partner with correct tags in 'or' configuration."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=[['EaSt', 'wEsT']]),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_date_after(self):
"""Should show only partner with last_action_time after date."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
date=DateRangeFilter([datetime(2015, 10, 1), None])), [])
names = {r['name'] for r in recs}
expected = {self.partner_b.name}
self.assertEqual(expected, names)
def test_order(self):
"""Check ordering results works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(),
["-name"])
names = [r['name'] for r in recs]
expected = [self.partner_b.name, self.partner_a.name]
self.assertEqual(expected, names)
def test_filter_by_date_before(self):
"""Should show only partner with last_action_time before date."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
date=DateRangeFilter([None, datetime(2015, 9, 30)])),
[])
names = {r['name'] for r in recs}
expected = {self.partner_a.name}
self.assertEqual(expected, names)
def test_filter_by_tags_and(self):
"""Show only partner with correct tags in 'and' configuration."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=[['EaSt'], ['wEsT']]),
[])
names = set([r['name'] for r in recs])
expected = set()
self.assertEqual(expected, names)
# Now try adding another tag.
self.partner_a.tags.add(self.west_tag)
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=[['EaSt'], ['wEsT']]),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_a.name}
self.assertEqual(expected, names)
def test_filter_by_date_after(self):
"""Should show only partner with last_action_time after date."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
date=[datetime(2015, 10, 1), None]),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_empty_things(self):
"""Empty filters should not filter, just like missing filters."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
locations={'city': '', 'state': ''}),
[])
names = set([r['name'] for r in recs])
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_tags_or(self):
"""Show only partner with correct tags in 'or' configuration."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=AndGroupFilter([
OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])),
[])
names = {r['name'] for r in recs}
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_tags_or(self):
"""Show only partner with correct tags in 'or' configuration."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=AndGroupFilter(
[OrGroupFilter([MatchFilter('EaSt'),
MatchFilter('wEsT')])])), [])
names = {r['name'] for r in recs}
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
def test_filter_by_city(self):
"""Should show only partners with correct city."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(locations=CompositeAndFilter({
'city':
MatchFilter('Los Angeles'),
})), [])
names = [r['name'] for r in recs]
expected = [self.partner_b.name]
self.assertEqual(expected, names)
def test_values(self):
"""Check limiting values works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(),
["name", "uri"])
expected = [
{'name': self.partner_a.name, 'uri': 'http://www.example.com/'},
{'name': self.partner_b.name, 'uri': 'http://www.asdf.com/'},
]
self.assertEqual(expected, recs)
def test_filter_by_city(self):
"""Should show only partners with correct city."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
locations={
'city': 'Los Angeles'
}),
[])
names = [r['name'] for r in recs]
expected = [self.partner_b.name]
self.assertEqual(expected, names)
def test_filter_by_state(self):
"""Should show only partners with correct state."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
locations=CompositeAndFilter({
'state': MatchFilter('CA'),
})),
[])
names = [r['name'] for r in recs]
expected = [self.partner_b.name]
self.assertEqual(expected, names)
def test_filter_by_tags_and(self):
"""Show only partner with correct tags in 'and' configuration."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(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.partner_a.tags.add(self.west_tag)
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=AndGroupFilter([
OrGroupFilter([MatchFilter('EaSt')]),
OrGroupFilter([MatchFilter('wEsT')])
])), [])
names = {r['name'] for r in recs}
expected = {self.partner_a.name}
self.assertEqual(expected, names)
def test_values(self):
"""Check limiting values works at all."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(self.company, PartnersFilter(),
["name", "uri"])
expected = [
{
'name': self.partner_a.name,
'uri': 'http://www.example.com/'
},
{
'name': self.partner_b.name,
'uri': 'http://www.asdf.com/'
},
]
self.assertEqual(expected, recs)
def test_run_unfiltered(self):
"""Make sure we only get data for this user."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(self.company, PartnersFilter(), [])
names = set([r['name'] for r in recs])
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
expected_tags = {
self.partner_a.pk: {'east'},
self.partner_b.pk: {'west'},
}
def tags_by_pk(rec):
return (rec['partner_id'], set(t['name'] for t in rec['tags']))
found_tags = dict(tags_by_pk(r) for r in recs)
self.assertEqual(expected_tags, found_tags)
def test_run_unfiltered(self):
"""Make sure we only get data for this user."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(self.company, PartnersFilter(), [])
names = {r['name'] for r in recs}
expected = {self.partner_a.name, self.partner_b.name}
self.assertEqual(expected, names)
expected_tags = {
self.partner_a.pk: {'east'},
self.partner_b.pk: {'west'},
}
def tags_by_pk(rec):
return (rec['partner_id'], set(t['name'] for t in rec['tags']))
found_tags = dict(tags_by_pk(r) for r in recs)
self.assertEqual(expected_tags, found_tags)
