def setUp(self):
super(UnsubscribingTests, self).setUp()
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(user=self.user,
email=self.user.email,
partner=self.partner)
self.num_emails = len(mail.outbox)
def test_send_pss_fails(self, mock_send_email):
"""
When a partner saved search fails to send, we should not imply
that it was successful.
"""
company = CompanyFactory()
partner = PartnerFactory(owner=company)
search = PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner)
e = SMTPAuthenticationError(418, 'Toot toot')
mock_send_email.side_effect = e
self.assertEqual(ContactRecord.objects.count(), 0)
self.assertEqual(SavedSearchLog.objects.count(), 0)
search.send_email()
record = ContactRecord.objects.get()
log = SavedSearchLog.objects.get()
self.assertFalse(log.was_sent)
self.assertEqual(log.reason, "Toot toot")
self.assertTrue(record.notes.startswith(log.reason))
self.assertFalse(record.contactlogentry.successful)
def setUp(self):
super(PartnerSavedSearchTests, self).setUp()
self.digest = SavedSearchDigestFactory(user=self.user)
self.company = CompanyFactory()
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(user=self.user, partner=self.partner)
self.partner_search = PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=self.company,
partner=self.partner)
# Partner searches are normally created with a form, which creates
# invitations as a side effect. We're not testing the form, so we
# can fake an invitation here.
invitation = Invitation.objects.create(
invitee_email=self.partner_search.email,
invitee=self.partner_search.user,
inviting_user=self.partner_search.created_by,
inviting_company=self.partner_search.partner.owner,
added_saved_search=self.partner_search)
invitation.send(self.partner_search)
self.num_occurrences = lambda text, search_str: [
match.start() for match in re.finditer(search_str, text)
]
# classes and ids may get stripped out when pynliner inlines css.
# all jobs contain a default (blank) icon, so we can search for that if
# we want a job count
self.job_icon = 'http://png.nlx.org/100x50/logo.gif'
def test_filtered_report(self):
"""Run a dynamic report with a filter."""
partner = PartnerFactory(owner=self.company)
for i in range(0, 10):
location = LocationFactory.create(city="city-%s" % i)
ContactFactory.create(name="name-%s" % i,
partner=partner,
locations=[location])
report_data = (self.dynamic_models['report_type/data_type']
['contacts/unaggregated'])
report = DynamicReport.objects.create(report_data=report_data,
filters=json.dumps({
'locations': {
'city': 'city-2',
},
}),
owner=self.company)
report.regenerate()
expected_column_names = {
'name', 'tags', 'notes', 'locations', 'phone', 'partner', 'email',
'date'
}
self.assertEqual(1, len(report.python))
self.assertEqual('name-2', report.python[0]['name'])
self.assertEqual(expected_column_names, set(report.python[0]))
def test_contact_record_counts_vs_list(self):
"""
ContactRecord counts for Communication Records and Referals
should match summed counts from contacts.
"""
contacts = ContactFactory.create_batch(4)
contacts[0].name = 'Other name'
contacts[1].email = '*****@*****.**'
contacts[2].partner = PartnerFactory(name='Other Partner')
for contact in contacts:
ContactRecordFactory.create(contact_type="job",
contact=contact,
partner=contact.partner)
ContactRecordFactory.create(contact_type='email',
contact=contact,
partner=contact.partner)
contacts[0].email = '*****@*****.**'
ContactRecordFactory.create(contact_type='email',
contact=contacts[0],
partner=contact.partner)
queryset = ContactRecord.objects.all()
self.assertEqual(queryset.count(), 9)
contacts = list(queryset.contacts)
sum_referrals = sum([contact['referrals'] for contact in contacts])
sum_records = sum([contact['records'] for contact in contacts])
self.assertEqual(sum_referrals, queryset.referrals)
self.assertEqual(sum_records, queryset.communication_activity.count())
def test_dynamic_partners_report_comm_per_month(self):
"""Run the comm_rec per month per partner report."""
self.client.login_user(self.user)
partner = PartnerFactory(owner=self.company)
partner.tags.add(TagFactory.create(name="this"))
contact = ContactFactory.create(name='somename', partner=partner)
for i in range(0, 20):
# unicode here to push through report generation/download
ContactRecordFactory(partner=partner,
contact=contact,
date_time=datetime(2015, 2, 4),
subject=u"subject-%s \u2019" % i)
report_data = self.find_report_data(
'partners', data_type="count_comm_rec_per_month")
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
'filter': json.dumps({
'tags': [['this']],
}),
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'partners'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(
report_data, 'json_pass')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
response_data = json.loads(resp.content)
self.assertEquals(12, len(response_data['records']))
january = response_data['records'][0]
self.assertEqual('1', january['Month'])
self.assertEqual('0', january['Communication Record Count'])
february = response_data['records'][1]
self.assertEqual('2', february['Month'])
self.assertEqual('20', february['Communication Record Count'])
def test_only_user_results_returned(self):
"""Results should only contain records user has access to."""
# records not owned by user
partner = PartnerFactory(name="Wrong Partner")
ContactRecordFactory.create_batch(10, partner=partner)
self.client.path += '/contactrecord'
response = self.client.post()
output = json.loads(response.content)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(output), 10)
def test_dynamic_partners_report_sort(self):
"""Make sure the document is sorted the way we expect.
"""
self.client.login_user(self.user)
for i in range(0, 20):
# unicode here to push through report generation/download
PartnerFactory(owner=self.company,
name=u"partner-%s \u2019" % i,
uri="somewhere")
report_data = self.find_report_data('partners')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'partners'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(
report_data, 'json_pass')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
'direction': 'descending',
'order_by': 'Name',
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
response_data = json.loads(resp.content)
self.assertEquals(21, len(response_data['records']))
found_name = response_data['records'][0]['Name']
expected_name = u'partner-9 \u2019'
self.assertEqual(expected_name, found_name)
def test_send_pss_after_10(self):
"""
Ensures that partner saved searches that are created and scheduled for
today are sent immediately if they are saved after the batch sending
process begins.
"""
company = CompanyFactory()
partner = PartnerFactory(owner=company)
communication_records = ContactRecord.objects.count()
# The act of creating a daily partner saved search after 10 AM should
# send the saved search being created.
PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner,
frequency='D')
self.assertEqual(ContactRecord.objects.count(),
communication_records + 1,
msg=("No communication record after "
"daily search creation"))
today = datetime.date.today()
# Creating a weekly partner saved search with a day_of_week of today
# should send the saved search on save.
PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner,
frequency='W',
day_of_week=today.isoweekday())
self.assertEqual(ContactRecord.objects.count(),
communication_records + 2,
msg=("No communication record after "
"weekly search creation"))
PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner,
frequency='M',
day_of_month=today.day)
self.assertEqual(ContactRecord.objects.count(),
communication_records + 3,
msg=("No communication record after "
"monthly search creation"))
def test_dynamic_comm_records_report(self):
"""Create some test data, run, list, and download a commrec report."""
self.client.login_user(self.user)
partner = PartnerFactory(owner=self.company)
contact = ContactFactory.create(name='somename', partner=partner)
for i in range(0, 20):
# unicode here to push through report generation/download
ContactRecordFactory(partner=partner,
contact=contact,
subject=u"subject-%s \u2019" % i)
report_data = self.find_report_data('comm_records')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'communication-records'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(
report_data, 'json_pass')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
response_data = json.loads(resp.content)
self.assertEquals(20, len(response_data['records']))
last_subject = response_data['records'][-1]['Subject']
expected_subject = u'subject-19 \u2019'
self.assertEqual(expected_subject, last_subject)
def test_dynamic_partners_report_csv_limit_columns(self):
"""Make sure the document contains only the columns we care about.
"""
self.client.login_user(self.user)
for i in range(0, 20):
# unicode here to push through report generation/download
PartnerFactory(owner=self.company,
name=u"partner-%s \u2019" % i,
uri="somewhere")
report_data = self.find_report_data('partners')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'partners'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(report_data, 'csv')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
'values': ['uri', 'name'],
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
self.assertIn('The_Report.csv', resp['content-disposition'])
self.assertIn('text/csv', resp['content-type'])
lines = resp.content.splitlines()
self.assertEquals('URL,Name', lines[0])
self.assertEquals('somewhere,partner-0 \xe2\x80\x99', lines[2])
def test_widget_with_partner_saved_search(self):
company = CompanyFactory()
partner = PartnerFactory(owner=company)
ContactFactory(user=self.user, partner=partner)
search = PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner)
response = self.client.get(reverse('saved_search_widget') +
'?url=%s&callback=callback' % (
search.url, ))
edit_url = '\\"https://secure.my.jobs%s?id=%s&pss=True\\"' % (
reverse('edit_search'), search.pk)
self.assertTrue(edit_url in response.content)
def test_dynamic_contacts_report(self):
"""Create some test data, run, list, and download a contacts report."""
self.client.login_user(self.user)
partner = PartnerFactory(owner=self.company)
for i in range(0, 10):
# unicode here to push through report generation/download
ContactFactory.create(name=u"name-%s \u2019" % i, partner=partner)
report_data = self.find_report_data('contacts')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'contacts'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(
report_data, 'json_pass')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
response_data = json.loads(resp.content)
self.assertEquals(10, len(response_data['records']))
first_found_name = response_data['records'][0]['Name']
expected_name = u'name-0 \u2019'
self.assertEqual(expected_name, first_found_name)
def setUp(self):
super(SavedSearchSendingTests, self).setUp()
self.feed = 'http://rushenterprises-veterans.jobs/alabama/usa/jobs/feed/rss'
self.saved_search = SavedSearchFactory(user=self.user,
feed=self.feed,
frequency='D')
self.company = CompanyFactory()
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(user=self.user, partner=self.partner)
self.partner_search = PartnerSavedSearchFactory(user=self.user,
feed=self.feed,
frequency='D',
created_by=self.user,
provider=self.company,
partner=self.partner)
mail.outbox = []
def test_report(self):
"""Run a dynamic report through its paces."""
partner = PartnerFactory(owner=self.company)
for i in range(0, 10):
ContactFactory.create(name="name-%s" % i, partner=partner)
report_data = (self.dynamic_models['report_type/data_type']
['contacts/unaggregated'])
report = DynamicReport.objects.create(report_data=report_data,
owner=self.company)
report.regenerate()
expected_column_names = {
'name', 'tags', 'notes', 'locations', 'phone', 'partner', 'email',
'date'
}
self.assertEqual(10, len(report.python))
self.assertEqual(expected_column_names, set(report.python[0]))
def test_dynamic_partners_report_xlsx(self):
"""Run a report through the xlsx presentation type.
Just make sure the document loads.
"""
self.client.login_user(self.user)
for i in range(0, 20):
# unicode here to push through report generation/download
PartnerFactory(owner=self.company, name=u"partner-%s \u2019" % i)
report_data = self.find_report_data('partners')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id': report_data.pk,
'name': 'The Report',
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
resp = self.client.get(reverse('list_dynamic_reports'))
self.assertEqual(200, resp.status_code)
self.assertEqual(
{
'reports': [
{
'id': report_id,
'name': 'The Report',
'report_type': 'partners'
},
]
}, json.loads(resp.content))
report_presentation = self.find_report_presentation(
report_data, 'xlsx')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
self.assertIn('The_Report.xlsx', resp['content-disposition'])
self.assertIn('application/vnd.', resp['content-type'])
def test_pss_contact_record_tagged(self):
"""
When a contact record is created from a saved search being sent, that
record should have the saved search's tag.
"""
company = CompanyFactory()
partner = PartnerFactory(owner=company)
tag = TagFactory(name="Test Tag")
search = PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=company,
partner=partner)
search.tags.add(tag)
search.send_email()
record = ContactRecord.objects.get(tags__name=tag.name)
self.assertTrue(record.contactlogentry.successful)
def test_dynamic_report_with_filter(self):
"""Create some test data, run filtered, and download a report."""
self.client.login_user(self.user)
partner = PartnerFactory(owner=self.company)
for i in range(0, 10):
location = LocationFactory.create(city="city-%s" % i)
ContactFactory.create(name="name-%s" % i,
partner=partner,
locations=[location])
report_data = self.find_report_data('contacts')
resp = self.client.post(reverse('run_dynamic_report'),
data={
'report_data_id':
report_data.pk,
'name':
'The Report',
'filter':
json.dumps({
'locations': {
'city': 'city-2',
},
}),
})
self.assertEqual(200, resp.status_code)
report_id = json.loads(resp.content)['id']
report_presentation = self.find_report_presentation(
report_data, 'json_pass')
data = {
'id': report_id,
'report_presentation_id': report_presentation.pk,
}
resp = self.client.get(reverse('download_dynamic_report'), data)
self.assertEquals(200, resp.status_code)
response_data = json.loads(resp.content)
self.assertEquals(1, len(response_data['records']))
found_name = response_data['records'][0]['Name']
expected_name = u'name-2'
self.assertEqual(expected_name, found_name)
def setUp(self):
super(MergeUserTests, self).setUp()
self.client = TestClient()
self.password = '******'
self.key = '56effea3df2bcdcfe377ca4bf30f2844be47d012'
self.existing = User.objects.create(email="*****@*****.**",
user_guid="a")
self.existing.set_password(self.password)
self.new_user = User.objects.create(email="*****@*****.**",
user_guid="b")
self.activation_profile = ActivationProfile.objects.create(
user=self.new_user, email="*****@*****.**")
self.activation_profile.activation_key = self.key
self.activation_profile.save()
self.partner = PartnerFactory()
for _ in range(0, 10):
Contact.objects.create(user=self.new_user, partner=self.partner)
SavedSearch.objects.create(user=self.new_user)
def test_dynamic_contacts_trial_report(self):
"""Run a trial report."""
self.maxDiff = 10000
self.client.login_user(self.user)
partner = PartnerFactory(owner=self.company)
for i in range(0, 10):
location = LocationFactory.create(city="city-%s" % i, state='ZZ')
# unicode here to push through report generation/download
ContactFactory.create(name=u"name-%s \u2019" % i,
partner=partner,
locations=[location])
report_data = self.find_report_data('contacts')
resp = self.client.post(reverse('run_trial_dynamic_report'),
data={
'report_data_id':
report_data.pk,
'name':
'The Report',
'filter':
json.dumps({
'locations': {
'city': 'city-2',
},
}),
'values':
json.dumps(
['phone', 'tags', 'email', 'name']),
})
self.assertEqual(200, resp.status_code)
report_content = json.loads(resp.content)
self.assertEqual([
{
u'email': u'*****@*****.**',
u'name': u'name-2 \u2019',
u'phone': u'84104391',
u'tags': [],
},
], report_content)
def test_date_filters(self):
"""
Filter by activity start and end date.
"""
end_date = datetime.now().date()
# randomly create partners and assign them contact records ranging from
# 60 days ago to now.
partners = [PartnerFactory(owner=self.company) for i in range(3)]
partners.append(self.partner)
# we want the contact records to exist before the tests, hence the
# second for loop
for days in [60, 30, 1, 0]:
ContactRecordFactory(partner=random.choice(partners),
date_time=end_date - timedelta(days))
for days in [60, 30, 1, 0]:
start_date = (datetime.now() - timedelta(days)).date()
request = self.request_factory.get(
'prm/view/partner-library', dict(
company=self.company.id,
start_date=start_date.strftime("%m/%d/%Y"),
end_date=end_date.strftime("%m/%d/%Y")))
request.user = self.staff_user
partners = helpers.filter_partners(request)
for partner in partners:
date_times = [c.date_time.date()
for c in partner.contactrecord_set.all()]
# ensure that for each partner, at least one contact record is
# within range
if partner.contactrecord_set.all():
self.assertTrue(filter(
lambda x: start_date <= x <= end_date , date_times))
def setUp(self):
super(PartnerSavedSearchFormTests, self).setUp()
self.role.activities = self.activities
CompanyUserFactory(user=self.user, company=self.company)
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(user=None, email='*****@*****.**',
partner=self.partner)
self.partner_search_data = {
'url': 'http://www.my.jobs/jobs',
'feed': 'http://www.my.jobs/jobs/feed/rss?',
'frequency': 'D',
'label': 'All jobs from www.my.jobs',
'sort_by': 'Relevance',
'jobs_per_email': 5,
'email': self.contact.email,
'partner_message': "some partner message"
}
settings.SITE = SeoSite.objects.first()
settings.SITE.canonical_company = self.company
settings.SITE.save()
# This request is only used in RequestForms, where all we care about
# is request.user.
self.request = RequestFactory().get(
reverse('partner_savedsearch_save'))
self.request.user = self.user
self.request.impersonator = None
form = PartnerSavedSearchForm(partner=self.partner,
data=self.partner_search_data,
request=self.request)
instance = form.instance
instance.provider = self.company
instance.partner = self.partner
instance.created_by = self.user
instance.custom_message = instance.partner_message
self.assertTrue(form.is_valid())
self.instance = form.save()
def setUp(self):
super(MyPartnerTests, self).setUp()
self.company = CompanyFactory()
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(partner=self.partner)
def setUp(self):
super(TestContactsDataSource, self).setUp()
# A company to work with
self.company = CompanyFactory(name='right')
self.company.save()
# A separate company that should not show up in results.
self.other_company = CompanyFactory(name='wrong')
self.other_company.save()
self.partner = PartnerFactory(owner=self.company)
self.other_partner = PartnerFactory(owner=self.other_company)
self.partner_a = PartnerFactory(owner=self.company, name="aaa")
self.partner_b = PartnerFactory(owner=self.company, name="bbb")
# An unapproved parther. Associated data should be filtered out.
self.partner_unapp = PartnerFactory(
owner=self.company,
name="unapproved",
approval_status__code=Status.UNPROCESSED)
# An archived parther. Associated data should be filtered out.
self.partner_archived = PartnerFactory(owner=self.company)
self.east_tag = TagFactory.create(company=self.company,
name='east',
hex_color="aaaaaa")
self.west_tag = TagFactory.create(company=self.company,
name='west',
hex_color="bbbbbb")
self.left_tag = TagFactory.create(company=self.company,
name='left',
hex_color="cccccc")
self.right_tag = TagFactory.create(company=self.company,
name='right',
hex_color="dddddd")
self.bad_tag = TagFactory.create(company=self.company,
name='bad',
hex_color="cccccc")
self.partner_a.tags.add(self.left_tag)
self.partner_b.tags.add(self.right_tag)
self.john_user = UserFactory(email="*****@*****.**")
self.john = ContactFactory(partner=self.partner_a,
name='john adams',
user=self.john_user,
email="*****@*****.**",
last_action_time='2015-10-03')
self.john.locations.add(
LocationFactory.create(city="Indianapolis", state="IN"))
self.john.locations.add(
LocationFactory.create(city="Chicago", state="IL"))
self.john.tags.add(self.east_tag)
self.sue_user = UserFactory(email="*****@*****.**")
self.sue = ContactFactory(partner=self.partner_b,
name='Sue Baxter',
user=self.sue_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.sue.locations.add(
LocationFactory.create(address_line_one="123",
city="Los Angeles",
state="CA"))
self.sue.locations.add(
LocationFactory.create(address_line_one="234",
city="Los Angeles",
state="CA"))
self.sue.tags.add(self.west_tag)
# Poision data. Should never show up.
self.archived_partner_user = (UserFactory(
email="*****@*****.**"))
self.archived_partner = ContactFactory(
partner=self.partner_archived,
name='Archived Partner Contact',
user=self.archived_partner_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.archived_partner.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.archived_partner.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.archived_partner.tags.add(self.west_tag)
# Poision data. Should never show up.
self.archived_contact_user = (UserFactory(
email="*****@*****.**"))
self.archived_contact = ContactFactory(
partner=self.partner_b,
name='Archived Contact',
user=self.archived_contact_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.archived_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.archived_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.archived_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.unapproved_partner_user = (UserFactory(
email="*****@*****.**"))
self.unapproved_partner_contact = ContactFactory(
partner=self.partner_unapp,
name='Unapproved Partner Contact',
user=self.unapproved_partner_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.unapproved_partner_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.unapproved_partner_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.unapproved_partner_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.unapproved_contact_user = (UserFactory(
email="*****@*****.**"))
self.unapproved_contact = ContactFactory(
partner=self.partner_b,
name='Unapproved Contact',
user=self.unapproved_contact_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23',
approval_status__code=Status.UNPROCESSED)
self.unapproved_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.unapproved_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.unapproved_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.wrong_user = UserFactory(email="*****@*****.**")
self.wrong = ContactFactory(partner=self.other_partner,
name='wrong person',
user=self.wrong_user,
email="*****@*****.**",
last_action_time='2015-09-03')
self.wrong.locations.add(
LocationFactory.create(city="Los Angeles", state="CA"))
self.wrong.tags.add(self.east_tag)
self.wrong.tags.add(self.west_tag)
self.wrong.tags.add(self.bad_tag)
# Archive archived data here. Doing this earlier in the set up results
# in odd exceptions.
self.partner_archived.archive()
self.archived_contact.archive()
def setUp(self):
super(MyReportsTestCase, self).setUp()
self.role.activities = self.activities
self.partner = PartnerFactory(name='Test Partner', owner=self.company)
self.dynamic_models = create_full_fixture()
def setUp(self):
super(TestCommRecordsDataSource, self).setUp()
# A company to work with
self.company = CompanyFactory(name='right')
self.company.save()
# A separate company that should not show up in results.
self.other_company = CompanyFactory(name='wrong')
self.other_company.save()
self.partner_a = PartnerFactory(owner=self.company,
uri='http://www.example.com/',
data_source="zap",
name="aaa")
self.partner_b = PartnerFactory(owner=self.company,
uri='http://www.asdf.com/',
data_source="bcd",
name="bbb")
# An unapproved parther. Associated data should be filtered out.
self.partner_unapp = PartnerFactory(
owner=self.company,
name="unapproved",
approval_status__code=Status.UNPROCESSED)
# An archived parther. Associated data should be filtered out.
self.partner_archived = PartnerFactory(owner=self.company)
self.east_tag = TagFactory.create(company=self.company,
name='east',
hex_color="aaaaaa")
self.west_tag = TagFactory.create(company=self.company,
name='west',
hex_color="bbbbbb")
self.north_tag = TagFactory.create(company=self.company,
name='north',
hex_color="cccccc")
self.south_tag = TagFactory.create(company=self.company,
name='south',
hex_color="dddddd")
self.left_tag = TagFactory.create(company=self.company,
name='left',
hex_color="eeeeee")
self.right_tag = TagFactory.create(company=self.company,
name='right',
hex_color="ffffff")
self.bad_tag = TagFactory.create(company=self.company,
name='bad',
hex_color="cccccc")
self.partner_a.tags.add(self.left_tag)
self.partner_b.tags.add(self.right_tag)
self.john_user = UserFactory(email="*****@*****.**")
self.john = ContactFactory(partner=self.partner_a,
name='john adams',
user=self.john_user,
email="*****@*****.**",
last_action_time='2015-10-03')
self.john.locations.add(
LocationFactory.create(city="Indianapolis", state="IN"))
self.john.locations.add(
LocationFactory.create(city="Chicago", state="IL"))
self.john.tags.add(self.north_tag)
self.sue_user = UserFactory(email="*****@*****.**")
self.sue = ContactFactory(partner=self.partner_b,
name='Sue Baxter',
user=self.sue_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.sue.locations.add(
LocationFactory.create(address_line_one="123",
city="Los Angeles",
state="CA"))
self.sue.locations.add(
LocationFactory.create(address_line_one="234",
city="Los Angeles",
state="CA"))
self.sue.tags.add(self.south_tag)
self.partner_a.primary_contact = self.john
self.partner_b.primary_contact = self.sue
self.partner_a.save()
self.partner_b.save()
self.record_1 = ContactRecordFactory(subject='record 1',
date_time='2015-09-30 13:23',
contact=self.john,
contact_type="Email",
partner=self.partner_a,
location='Indianapolis, IN',
tags=[self.east_tag])
self.record_2 = ContactRecordFactory(subject='record 2',
date_time='2015-01-01',
contact=self.john,
contact_type="Meeting Or Event",
partner=self.partner_a,
location='Indianapolis, IN',
tags=[self.east_tag])
self.record_3 = ContactRecordFactory(subject='record 3',
date_time='2015-10-03',
contact=self.sue,
contact_type="Phone",
partner=self.partner_b,
location='Los Angeles, CA',
tags=[self.west_tag])
# Archive archived data here. Doing this earlier in the set up results
# in odd exceptions.
self.partner_archived.archive()
