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_help_data_source(self):
"""Check data_source help works at all."""
ds = PartnersDataSource()
recs = ds.help_data_source(
self.company,
PartnersFilter(),
"z")
actual = set([r['key'] for r in recs])
self.assertEqual({'zap'}, actual)
def test_help_city(self):
"""Check city help works and ignores current city filter."""
ds = PartnersDataSource()
recs = ds.help_city(
self.company,
PartnersFilter(locations={'city': "zz"}),
"angel")
actual = set([r['key'] for r in recs])
self.assertEqual({'Los Angeles'}, actual)
def test_help_state(self):
"""Check state help works and ignores current state filter."""
ds = PartnersDataSource()
recs = ds.help_state(
self.company,
PartnersFilter(locations={'state': "zz"}),
"i")
actual = set([r['key'] for r in recs])
self.assertEqual({'IL', 'IN'}, actual)
def test_help_uri(self):
"""Check uri help works at all."""
ds = PartnersDataSource()
recs = ds.help_uri(
self.company,
PartnersFilter(),
"ex")
actual = set([r['key'] for r in recs])
self.assertEqual({'http://www.example.com/'}, actual)
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_help_city(self):
"""Check city help works and ignores current city filter."""
ds = PartnersDataSource()
recs = ds.help_city(
self.company,
PartnersFilter(
locations=CompositeAndFilter({'city': MatchFilter("zz")})),
"angel")
actual = {r['value'] for r in recs}
self.assertEqual({'Los Angeles'}, actual)
def test_help_state(self):
"""Check state help works and ignores current state filter."""
ds = PartnersDataSource()
recs = ds.help_state(
self.company,
PartnersFilter(
locations=CompositeAndFilter({'state': MatchFilter("zz")})),
"i")
actual = {r['value'] for r in recs}
self.assertEqual({'IL', 'IN'}, actual)
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_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_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_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_help_state(self):
"""Check state help works and ignores current state filter."""
ds = PartnersDataSource()
recs = ds.help_state(
self.company,
PartnersFilter(locations=CompositeAndFilter({
'state': MatchFilter("zz")})),
"i")
actual = {r['value'] for r in recs}
self.assertEqual({'IL', 'IN'}, actual)
def test_help_city(self):
"""Check city help works and ignores current city filter."""
ds = PartnersDataSource()
recs = ds.help_city(
self.company,
PartnersFilter(locations=CompositeAndFilter({
'city': MatchFilter("zz")})),
"angel")
actual = {r['value'] for r in recs}
self.assertEqual({'Los Angeles'}, actual)
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_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_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_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_default_filter(self):
"""should produce a populated filter object."""
ds = PartnersDataSource()
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 = PartnersFilter(
date=DateRangeFilter([datetime(2014, 1, 1), None]))
self.assertEquals(expected, default_filter)
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_default_filter(self):
"""should produce a populated filter object."""
ds = PartnersDataSource()
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 = PartnersFilter(
date=DateRangeFilter([datetime(2014, 1, 1), None]))
self.assertEquals(expected, default_filter)
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_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_run_count_comm_rec_per_month_no_partners(self):
"""Trip over a bug in the mysql client driver."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(subject=subject,
date_time=datetime(2015, month, 1)))
ds = PartnersDataSource()
partners_filter = PartnersFilter(
tags=AndGroupFilter([OrGroupFilter([MatchFilter('zzz')])]))
recs = ds.run_count_comm_rec_per_month(self.company, partners_filter,
['name', 'year', '-month'])
self.assertEqual(0, len(recs))
def test_run_count_comm_rec_per_month_empty_partner(self):
"""One partner, no communication records."""
ds = PartnersDataSource()
partners_filter = PartnersFilter(
tags=AndGroupFilter([OrGroupFilter([MatchFilter('east')])]))
recs = ds.run_count_comm_rec_per_month(self.company, partners_filter,
['name', 'year', '-month'])
data = [(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs]
self.assertEqual(12, len(data))
default_year = datetime.now().year
for item in data:
self.assertEqual(default_year, item[1])
self.assertEqual(0, item[3])
def test_run_count_comm_rec_per_month_no_partners(self):
"""Trip over a bug in the mysql client driver."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(
subject=subject,
date_time=datetime(2015, month, 1)))
ds = PartnersDataSource()
partners_filter = PartnersFilter(tags=[['zzz']])
recs = ds.run_count_comm_rec_per_month(
self.company, partners_filter, ['name', 'year', '-month'])
self.assertEqual(0, len(recs))
def test_run_count_comm_rec_per_month_empty_partner(self):
"""One partner, no communication records."""
ds = PartnersDataSource()
partners_filter = PartnersFilter(tags=[['east']])
recs = ds.run_count_comm_rec_per_month(
self.company, partners_filter, ['name', 'year', '-month'])
data = [
(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs
]
self.assertEqual(12, len(data))
default_year = datetime.now().year
for item in data:
self.assertEqual(default_year, item[1])
self.assertEqual(0, item[3])
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 = {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_count_comm_rec_per_month_one_partner(self):
"""Trip over a bug in the mysql client driver."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for year in [2013, 2015, 2014]:
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(subject=subject,
date_time=datetime(
year, month, 1)))
ds = PartnersDataSource()
partners_filter = PartnersFilter(
tags=AndGroupFilter([OrGroupFilter([MatchFilter('west')])]))
recs = ds.run_count_comm_rec_per_month(self.company, partners_filter,
['name', 'year', '-month'])
data = [(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs]
self.assertEqual(36, len(data))
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_count_comm_rec_per_month_one_partner(self):
"""Trip over a bug in the mysql client driver."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for year in [2013, 2015, 2014]:
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(
subject=subject,
date_time=datetime(year, month, 1)))
ds = PartnersDataSource()
partners_filter = PartnersFilter(tags=[['west']])
recs = ds.run_count_comm_rec_per_month(
self.company, partners_filter, ['name', 'year', '-month'])
data = [
(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs
]
self.assertEqual(36, len(data))
def test_run_count_comm_rec_per_month(self):
"""Make sure we only get data for this user."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(
subject=subject,
date_time=datetime(2015, month, 1)))
ds = PartnersDataSource()
recs = ds.run_count_comm_rec_per_month(
self.company, PartnersFilter(), ['name', 'year', '-month'])
data = [
(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs
]
expected = [
(self.partner_a.name, 2015, 12, 0),
(self.partner_a.name, 2015, 11, 0),
(self.partner_a.name, 2015, 10, 0),
(self.partner_a.name, 2015, 9, 0),
(self.partner_a.name, 2015, 8, 0),
(self.partner_a.name, 2015, 7, 0),
(self.partner_a.name, 2015, 6, 0),
(self.partner_a.name, 2015, 5, 0),
(self.partner_a.name, 2015, 4, 0),
(self.partner_a.name, 2015, 3, 0),
(self.partner_a.name, 2015, 2, 0),
(self.partner_a.name, 2015, 1, 0),
(self.partner_b.name, 2015, 12, 0),
(self.partner_b.name, 2015, 11, 0),
(self.partner_b.name, 2015, 10, 0),
(self.partner_b.name, 2015, 9, 0),
(self.partner_b.name, 2015, 8, 0),
(self.partner_b.name, 2015, 7, 0),
(self.partner_b.name, 2015, 6, 0),
(self.partner_b.name, 2015, 5, 0),
(self.partner_b.name, 2015, 4, 3),
(self.partner_b.name, 2015, 3, 3),
(self.partner_b.name, 2015, 2, 3),
(self.partner_b.name, 2015, 1, 0),
]
self.assertEqual(expected, data)
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_run_count_comm_rec_per_month(self):
"""Make sure we only get data for this user."""
for (subject, itx) in enumerate(['a', 'b', 'c']):
for month in [2, 3, 4]:
self.sue.contactrecord_set.add(
ContactRecordFactory(subject=subject,
date_time=datetime(2015, month, 1)))
ds = PartnersDataSource()
recs = ds.run_count_comm_rec_per_month(self.company, PartnersFilter(),
[])
data = [(r['name'], r['year'], r['month'], r['comm_rec_count'])
for r in recs]
expected = [
(self.partner_a.name, 2015, 1, 0),
(self.partner_a.name, 2015, 2, 0),
(self.partner_a.name, 2015, 3, 0),
(self.partner_a.name, 2015, 4, 0),
(self.partner_a.name, 2015, 5, 0),
(self.partner_a.name, 2015, 6, 0),
(self.partner_a.name, 2015, 7, 0),
(self.partner_a.name, 2015, 8, 0),
(self.partner_a.name, 2015, 9, 0),
(self.partner_a.name, 2015, 10, 0),
(self.partner_a.name, 2015, 11, 0),
(self.partner_a.name, 2015, 12, 0),
(self.partner_b.name, 2015, 1, 0),
(self.partner_b.name, 2015, 2, 3),
(self.partner_b.name, 2015, 3, 3),
(self.partner_b.name, 2015, 4, 3),
(self.partner_b.name, 2015, 5, 0),
(self.partner_b.name, 2015, 6, 0),
(self.partner_b.name, 2015, 7, 0),
(self.partner_b.name, 2015, 8, 0),
(self.partner_b.name, 2015, 9, 0),
(self.partner_b.name, 2015, 10, 0),
(self.partner_b.name, 2015, 11, 0),
(self.partner_b.name, 2015, 12, 0),
]
self.assertEqual(expected, data)
def test_adorn_filter_items(self):
found_filter_items = {
'tags': ['east', 'west'],
'uri': 'http://www.example.com/',
}
expected = {
u'tags': {
'east': {
'value': u'east',
'display': u'east',
'hexColor': u'aaaaaa',
},
'west': {
'value': u'west',
'display': u'west',
'hexColor': u'bbbbbb',
},
},
}
ds = PartnersDataSource()
adorned_filter = ds.adorn_filter_items(
self.company, found_filter_items)
self.assertEqual(expected, adorned_filter)
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_adorn_filter_items(self):
found_filter_items = {
'tags': ['east', 'west'],
'uri': 'http://www.example.com/',
}
expected = {
u'tags': {
'east': {
'value': u'east',
'display': u'east',
'hexColor': u'aaaaaa',
},
'west': {
'value': u'west',
'display': u'west',
'hexColor': u'bbbbbb',
},
},
}
ds = PartnersDataSource()
adorned_filter = ds.adorn_filter_items(self.company,
found_filter_items)
self.assertEqual(expected, adorned_filter)
def test_help_tags_colors(self):
"""Tags should have colors"""
ds = PartnersDataSource()
recs = ds.help_tags(self.company, PartnersFilter(), "east")
self.assertEqual("aaaaaa", recs[0]['hexColor'])
from myreports.datasources.contacts import ContactsDataSource
from myreports.datasources.partners import PartnersDataSource
from myreports.datasources.comm_records import CommRecordsDataSource
from myreports.datasources.jsondriver import DataSourceJsonDriver
ds_json_drivers = {
'contacts': DataSourceJsonDriver(ContactsDataSource()),
'partners': DataSourceJsonDriver(PartnersDataSource()),
'comm_records': DataSourceJsonDriver(CommRecordsDataSource()),
}
def test_help_tags_colors(self):
"""Tags should have colors"""
ds = PartnersDataSource()
recs = ds.help_tags(self.company, PartnersFilter(), "east")
self.assertEqual("aaaaaa", recs[0]['hexColor'])
def test_help_tags(self):
"""Check tags help works at all."""
ds = PartnersDataSource()
recs = ds.help_tags(self.company, PartnersFilter(), "E")
actual = set([r['key'] for r in recs])
self.assertEqual({'east', 'west'}, actual)
def test_help_tags(self):
"""Check tags help works at all."""
ds = PartnersDataSource()
recs = ds.help_tags(self.company, PartnersFilter(), "E")
actual = {r['value'] for r in recs}
self.assertEqual({'east', 'west'}, actual)
def test_help_uri(self):
"""Check uri help works at all."""
ds = PartnersDataSource()
recs = ds.help_uri(self.company, PartnersFilter(), "ex")
actual = {r['value'] for r in recs}
self.assertEqual({'http://www.example.com/'}, actual)
def test_help_data_source(self):
"""Check data_source help works at all."""
ds = PartnersDataSource()
recs = ds.help_data_source(self.company, PartnersFilter(), "z")
actual = {r['value'] for r in recs}
self.assertEqual({'zap'}, actual)