def setUp(self):
self.staff_user = UserFactory()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.staff_user.groups.add(group)
self.staff_user.save()
self.company = CompanyFactory()
self.company.save()
self.admin = CompanyUserFactory(user=self.staff_user,
company=self.company)
self.admin.save()
self.microsite = MicrositeFactory(company=self.company)
self.microsite.save()
self.client = TestClient()
self.client.login_user(self.staff_user)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
url='http://test.jobs/search?q=django',
label='test Jobs')
self.candidate_user.save()
for i in range(5):
# Create 5 new users
user = UserFactory(email='*****@*****.**' % i)
for search in SEARCH_OPTS:
# Create 15 new searches and assign three per user
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=%s' % search,
label='%s Jobs' % search)
class PostajobTestBase(MyJobsBase):
def setUp(self):
super(PostajobTestBase, self).setUp()
self.user = UserFactory(password='******')
self.company = CompanyFactory(product_access=True, posting_access=True)
self.site = SeoSiteFactory(canonical_company=self.company)
self.bu = BusinessUnitFactory()
self.site.business_units.add(self.bu)
self.site.save()
self.company.job_source_ids.add(self.bu)
self.company.save()
self.company_user = CompanyUserFactory(user=self.user,
company=self.company)
SitePackageFactory(owner=self.company)
self.package = Package.objects.get()
self.sitepackage = SitePackage.objects.get()
self.sitepackage.sites.add(self.site)
self.product = ProductFactory(package=self.package, owner=self.company)
self.login_user()
def login_user(self, user=None):
if not user:
user = self.user
self.client.post(reverse('home'),
data={
'username': user.email,
'password': '******',
'action': 'login',
})
def setUp(self):
self.staff_user = UserFactory()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.staff_user.groups.add(group)
self.staff_user.save()
self.company = CompanyFactory()
self.company.save()
self.admin = CompanyUserFactory(user=self.staff_user,
company=self.company)
self.admin.save()
self.microsite = MicrositeFactory(company=self.company)
self.microsite.save()
self.client = TestClient()
self.client.login_user(self.staff_user)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
url='http://test.jobs/search?q=django',
label='test Jobs')
self.candidate_user.save()
for i in range(5):
# Create 5 new users
user = UserFactory(email='*****@*****.**' % i)
for search in SEARCH_OPTS:
# Create 15 new searches and assign three per user
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=%s' % search,
label='%s Jobs' % search)
def test_outreach_domain_unique_to_company(self):
"""
Allowed domains should be unique within a company, but not necessarily
across PRM.
"""
OutreachEmailDomain.objects.create(company=self.company,
domain="foo.bar")
# duplicate domains allowed between companies
company = CompanyFactory.create(name="A Whole New World")
OutreachEmailDomain.objects.create(company=company,
domain="foo.bar")
# dupliate domains disallowed within the same company
with self.assertRaises(IntegrityError):
OutreachEmailDomain.objects.create(company=self.company,
domain="foo.bar")
def setUp(self):
super(PostajobTestBase, self).setUp()
self.user = UserFactory(password='******')
self.company = CompanyFactory(product_access=True, posting_access=True)
self.site = SeoSiteFactory(canonical_company=self.company)
self.bu = BusinessUnitFactory()
self.site.business_units.add(self.bu)
self.site.save()
self.company.job_source_ids.add(self.bu)
self.company.save()
self.company_user = CompanyUserFactory(user=self.user,
company=self.company)
SitePackageFactory(owner=self.company)
self.package = Package.objects.get()
self.sitepackage = SitePackage.objects.get()
self.sitepackage.sites.add(self.site)
self.product = ProductFactory(package=self.package, owner=self.company)
self.login_user()
def setUp(self):
super(ModelTests, self).setUp()
self.user = User.objects.create(email='*****@*****.**')
self.company = CompanyFactory()
CompanyProfile.objects.create(company=self.company)
self.site = SeoSiteFactory()
self.bu = BusinessUnitFactory()
self.site.business_units.add(self.bu)
self.site.save()
self.company.job_source_ids.add(self.bu)
self.company.save()
# Use the newly created site for testing instead of secure.my.jobs.
settings.SITE = self.site
self.request_data = {
'title': 'title',
'company': self.company.id,
'reqid': '1',
'description': 'sadfljasdfljasdflasdfj',
'link': 'www.google.com',
'on_sites': '0',
'apply_info': '',
}
self.request_location = {
'city': 'Indianapolis',
'state': 'Indiana',
'state_short': 'IN',
'country': 'United States',
'country_short': 'USA',
'zipcode': '46268',
}
self.site_package_data = {
'name': 'Test Site Package',
}
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(name='east', hex_color="aaaaaa")
self.west_tag = TagFactory.create(name='west', hex_color="bbbbbb")
self.bad_tag = TagFactory.create(name='bad', hex_color="cccccc")
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.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.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()
class TestCommRecordsDataSource(MyJobsBase):
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(name='east', hex_color="aaaaaa")
self.west_tag = TagFactory.create(name='west', hex_color="bbbbbb")
self.bad_tag = TagFactory.create(name='bad', hex_color="cccccc")
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.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.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()
def test_run_unfiltered(self):
"""Make sure we only get data for this user."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(self.company, CommRecordsFilter(), [])
subjects = set([r['subject'] for r in recs])
expected = {
self.record_1.subject,
self.record_2.subject,
self.record_3.subject,
}
self.assertEqual(expected, subjects)
def test_filter_by_date_range(self):
"""Should show only commrec with last_action_time in range."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
date_time=[datetime(2015, 9, 1), datetime(2015, 9, 30)]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject}
self.assertEqual(expected, subjects)
def test_filter_by_date_before(self):
"""Should show only commrec with last_action_time before date."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
date_time=[None, datetime(2015, 9, 30)]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject, self.record_2.subject}
self.assertEqual(expected, subjects)
def test_filter_by_date_after(self):
"""Should show only commrec with last_action_time after date."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
date_time=[datetime(2015, 10, 1), None]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_3.subject}
self.assertEqual(expected, subjects)
def test_filter_by_state(self):
"""Should show only commrecs with correct state."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
locations={
'state': 'CA'
}),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_3.subject}
self.assertEqual(expected, subjects)
def test_filter_by_city(self):
"""Should show only commrecs with correct city."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
locations={
'city': 'Los Angeles'
}),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_3.subject}
self.assertEqual(expected, subjects)
def test_filter_by_tags(self):
"""Show only commrec with correct tags."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(tags=[['EaSt']]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject, self.record_2.subject}
self.assertEqual(expected, subjects)
def test_filter_by_tags_or(self):
"""Show only commrec with correct tags in 'or' configuration."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(tags=[['EaSt', 'wEsT']]),
[])
subjects = set([r['subject'] for r in recs])
expected = {
self.record_1.subject,
self.record_2.subject,
self.record_3.subject,
}
self.assertEqual(expected, subjects)
def test_filter_by_tags_and(self):
"""Show only commrec with correct tags in 'and' configuration."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(tags=[['EaSt'], ['wEsT']]),
[])
subjects = set([r['subject'] for r in recs])
expected = set()
self.assertEqual(expected, subjects)
# Now try adding another tag.
self.record_1.tags.add(self.west_tag)
self.record_1.save()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(tags=[['EaSt'], ['wEsT']]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject}
self.assertEqual(expected, subjects)
def test_filter_by_empty_things(self):
"""Empty filters should not filter, just like missing filters."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(
locations={'city': '', 'state': ''}),
[])
subjects = set([r['subject'] for r in recs])
expected = {
self.record_1.subject,
self.record_2.subject,
self.record_3.subject,
}
self.assertEqual(expected, subjects)
def test_filter_by_communication_type(self):
"""Check communication_type filter works at all."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(communication_type='Email'),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject}
self.assertEqual(expected, subjects)
def test_filter_by_partner(self):
"""Check partner filter works at all."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(partner=[self.partner_a.pk]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_1.subject, self.record_2.subject}
self.assertEqual(expected, subjects)
def test_filter_by_contact(self):
"""Check partner filter works at all."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(contact=[self.sue.pk]),
[])
subjects = set([r['subject'] for r in recs])
expected = {self.record_3.subject}
self.assertEqual(expected, subjects)
def test_help_city(self):
"""Check city help works and ignores current city filter."""
ds = CommRecordsDataSource()
recs = ds.help_city(
self.company,
CommRecordsFilter(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 = CommRecordsDataSource()
recs = ds.help_state(
self.company,
CommRecordsFilter(locations={'state': "zz"}),
"i")
actual = set([r['key'] for r in recs])
self.assertEqual({'IL', 'IN'}, actual)
def test_help_tags(self):
"""Check tags help works at all."""
ds = CommRecordsDataSource()
recs = ds.help_tags(self.company, CommRecordsFilter(), "E")
actual = set([r['key'] for r in recs])
self.assertEqual({'east', 'west'}, actual)
def test_help_tags_colors(self):
"""Tags should have colors"""
ds = CommRecordsDataSource()
recs = ds.help_tags(self.company, CommRecordsFilter(), "east")
self.assertEqual("aaaaaa", recs[0]['hexColor'])
def test_help_communication_types(self):
"""Check communication_types help works at all."""
ds = CommRecordsDataSource()
recs = ds.help_communication_type(
self.company, CommRecordsFilter(), "ph")
actual = set([r['key'] for r in recs])
self.assertEqual({'Phone'}, actual)
def test_help_partner(self):
"""Check partner help works at all."""
ds = CommRecordsDataSource()
recs = ds.help_partner(self.company, CommRecordsFilter(), "A")
self.assertEqual(
[{'key': self.partner_a.pk, 'display': self.partner_a.name}],
recs)
def test_help_contact(self):
"""Check contact help works at all."""
ds = CommRecordsDataSource()
recs = ds.help_contact(self.company, CommRecordsFilter(), "U")
self.assertEqual(
[{'key': self.sue.pk, 'display': self.sue.name}],
recs)
def test_order(self):
"""Check ordering results works at all."""
ds = CommRecordsDataSource()
recs = ds.run_unaggregated(
self.company,
CommRecordsFilter(),
["-subject"])
subjects = [r['subject'] for r in recs]
expected = [
self.record_3.subject,
self.record_2.subject,
self.record_1.subject,
]
self.assertEqual(expected, subjects)
class TestPartnersDataSource(MyJobsBase):
def setUp(self):
super(TestPartnersDataSource, 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,
last_action_time='2015-09-30 13:23',
uri='http://www.example.com/',
data_source="zap",
name="aaa")
self.partner_b = PartnerFactory(
owner=self.company,
last_action_time='2015-10-03',
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(name='east', hex_color="aaaaaa")
self.west_tag = TagFactory.create(name='west', hex_color="bbbbbb")
self.bad_tag = TagFactory.create(name='bad', hex_color="cccccc")
self.partner_a.tags.add(self.east_tag)
self.partner_b.tags.add(self.west_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.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.partner_a.primary_contact = self.john
self.partner_b.primary_contact = self.sue
self.partner_a.save()
self.partner_b.save()
# Archive archived data here. Doing this earlier in the set up results
# in odd exceptions.
self.partner_archived.archive()
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(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_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_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_filter_by_date_range(self):
"""Should show only partner with last_action_time in range."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
date=[datetime(2015, 9, 1), datetime(2015, 9, 30)]),
[])
names = set([r['name'] for r in recs])
expected = {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=[None, datetime(2015, 9, 30)]),
[])
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_state(self):
"""Should show only partners with correct state."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(
locations={
'state': 'CA'
}),
[])
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_tags(self):
"""Show only partner with correct tags."""
ds = PartnersDataSource()
recs = ds.run_unaggregated(
self.company,
PartnersFilter(tags=[['EaSt']]),
[])
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_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_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_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_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_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_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_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_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_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_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)
class ModelTests(MyJobsBase):
def setUp(self):
super(ModelTests, self).setUp()
self.user = User.objects.create(email='*****@*****.**')
self.company = CompanyFactory()
CompanyProfile.objects.create(company=self.company)
self.site = SeoSiteFactory()
self.bu = BusinessUnitFactory()
self.site.business_units.add(self.bu)
self.site.save()
self.company.job_source_ids.add(self.bu)
self.company.save()
# Use the newly created site for testing instead of secure.my.jobs.
settings.SITE = self.site
self.request_data = {
'title': 'title',
'company': self.company.id,
'reqid': '1',
'description': 'sadfljasdfljasdflasdfj',
'link': 'www.google.com',
'on_sites': '0',
'apply_info': '',
}
self.request_location = {
'city': 'Indianapolis',
'state': 'Indiana',
'state_short': 'IN',
'country': 'United States',
'country_short': 'USA',
'zipcode': '46268',
}
self.site_package_data = {
'name': 'Test Site Package',
}
def test_job_creation_and_deletion(self):
locations = JobLocationFactory.create_batch(5)
job = JobFactory(owner=self.company, created_by=self.user)
job.locations = locations
job.save()
self.assertEqual(Job.objects.all().count(), 1)
self.assertEqual(JobLocation.objects.all().count(), 5)
job.delete()
self.assertEqual(Job.objects.all().count(), 0)
self.assertEqual(JobLocation.objects.all().count(), 0)
def test_job_add_to_solr(self):
job = JobFactory(owner=self.company, created_by=self.user)
job.locations.add(JobLocationFactory())
job.add_to_solr()
guids = " OR ".join(job.guids())
query = "guid:%s" % guids
self.assertEqual(self.ms_solr.search(query).hits, 1)
def test_job_remove_from_solr(self):
job = JobFactory(owner=self.company, created_by=self.user)
locations = JobLocationFactory.create_batch(2)
job.locations = locations
job.save()
job.remove_from_solr()
guids = " OR ".join(job.guids())
query = "guid:%s" % guids
self.assertEqual(self.ms_solr.search(query).hits, 0)
def test_job_generate_guid(self):
guid = '1'*32
# Confirm that pre-assigned guids are not being overwritten.
location = JobLocationFactory(guid=guid)
self.assertEqual(guid, location.guid)
location.delete()
# Confirm that if a guid isn't assigned one is getting assigned
# to it properly.
location = JobLocationFactory()
self.assertIsNotNone(location.guid)
self.assertNotEqual(location.guid, guid)
def test_site_package_make_unique_for_site(self):
package = SitePackage.objects.create(**self.site_package_data)
package.make_unique_for_site(self.site)
self.assertEqual(self.site.site_package, package)
package.delete()
package = SitePackage.objects.create(**self.site_package_data)
for x in range(100, 110):
site = SeoSiteFactory(id=x, domain="%s.jobs" % x)
package.sites.add(site)
# Site packages with existing sites associated with it should still
# only end up with one associated site.
site = SeoSiteFactory(id=4000, domain="4000.jobs")
package.make_unique_for_site(site)
self.assertEqual(site.site_package, package)
def test_site_package_make_unique_for_company(self):
package = SitePackage.objects.create(**self.site_package_data)
package.make_unique_for_company(self.company)
self.assertEqual(self.company.site_package, package)
package.delete()
package = SitePackage.objects.create(**self.site_package_data)
for x in range(1000, 1003):
site = SeoSiteFactory(id=x, domain="%s.jobs" % x)
package.sites.add(site)
self.assertItemsEqual(package.sites.all().values_list('id', flat=True),
[1000, 1001, 1002])
for x in range(100, 103):
site = SeoSiteFactory(id=x, domain="%s.jobs" % x)
site.business_units.add(self.bu)
site.save()
# Site packages with existing sites associated with it should
# only end up with the sites for a company.
package.make_unique_for_company(self.company)
self.assertEqual(self.company.site_package, package)
self.assertItemsEqual(package.sites.all().values_list('id', flat=True),
[100, 101, 102, 2])
def create_purchased_job(self, pk=None):
if not hasattr(self, 'package'):
self.package = SitePackageFactory(owner=self.company)
if not hasattr(self, 'product'):
self.product = ProductFactory(
package=self.package, owner=self.company)
if not hasattr(self, 'purchased_product'):
self.purchased_product = PurchasedProductFactory(
product=self.product, owner=self.company)
exp_date = date.today() + timedelta(self.product.posting_window_length)
self.assertEqual(self.purchased_product.expiration_date, exp_date)
return PurchasedJobFactory(
owner=self.company, created_by=self.user,
purchased_product=self.purchased_product, pk=pk)
def test_purchased_job_add(self):
self.create_purchased_job()
self.assertEqual(PurchasedJob.objects.all().count(), 1)
self.assertEqual(SitePackage.objects.all().count(), 1)
self.assertEqual(Request.objects.all().count(), 1)
package = SitePackage.objects.get()
job = PurchasedJob.objects.get()
self.assertItemsEqual(job.site_packages.all(), [package])
def test_purchased_job_add_to_solr(self):
job = self.create_purchased_job()
job.locations.add(JobLocationFactory())
job.save()
# Add to solr and delete from solr shouldn't be called until
# the job is approved.
guids = " OR ".join(job.guids())
query = "guid:%s" % guids
self.assertEqual(self.ms_solr.search(query).hits, 0)
job.is_approved = True
# Jobs won't be added/deleted until it's confirmed that the
# purchased product is paid for as well.
job.purchased_product.paid = True
job.purchased_product.save()
job.save()
# Now that the job is approved, it should've been sent to solr.
guids = " OR ".join(job.guids())
query = "guid:%s" % guids
self.assertEqual(self.ms_solr.search(query).hits, 1)
def test_purchased_product_jobs_remaining(self):
num_jobs_allowed = Product._meta.get_field_by_name('num_jobs_allowed')
expected_num_jobs = num_jobs_allowed[0].default
for x in range(50, 50 + expected_num_jobs):
if hasattr(self, 'purchased_product'):
self.assertTrue(self.purchased_product.can_post_more())
self.create_purchased_job()
expected_num_jobs -= 1
self.assertEqual(self.purchased_product.jobs_remaining,
expected_num_jobs)
self.assertFalse(self.purchased_product.can_post_more())
def test_invoice_send_invoice_email(self):
self.create_purchased_job()
group, _ = Group.objects.get_or_create(name=Product.ADMIN_GROUP_NAME)
# No one to receive the email.
self.purchased_product.invoice.send_invoice_email()
self.assertEqual(len(mail.outbox), 0)
# Only recipient is specified recipient.
self.purchased_product.invoice.send_invoice_email(other_recipients=['*****@*****.**'])
self.assertItemsEqual(mail.outbox[0].to,
['*****@*****.**'])
mail.outbox = []
# Only recipients are admins.
user = CompanyUserFactory(user=self.user, company=self.company)
user.group.add(group)
user.save()
self.purchased_product.invoice.send_invoice_email()
self.assertItemsEqual(mail.outbox[0].to,
[u'*****@*****.**'])
self.assertItemsEqual(mail.outbox[0].from_email,
'*****@*****.**')
mail.outbox = []
self.site.email_domain = 'test.domain'
self.site.save()
# Recipients are admins + specified recipients.
self.purchased_product.invoice.send_invoice_email(other_recipients=['*****@*****.**'])
self.assertItemsEqual(mail.outbox[0].to,
['*****@*****.**', u'*****@*****.**'])
self.assertEqual(mail.outbox[0].from_email,
'*****@*****.**')
mail.outbox = []
# Only recipient is [email protected] (no admins)
self.purchased_product.invoice.send_invoice_email(send_to_admins=False,
other_recipients=['*****@*****.**'])
# Only one in .to should be [email protected]
self.assertEquals(len(mail.outbox[0].to), 1)
self.assertItemsEqual(mail.outbox[0].to, ['*****@*****.**'])
def test_invoice_unchanged_after_purchased_product_deletion(self):
self.create_purchased_job()
invoice = self.purchased_product.invoice
invoice.send_invoice_email(other_recipients=['*****@*****.**'])
old_email = mail.outbox.pop()
self.purchased_product.delete()
invoice.send_invoice_email(other_recipients=['*****@*****.**'])
new_email = mail.outbox.pop()
self.assertEqual(old_email.body, new_email.body)
def test_invoice_unchanged_after_product_changed(self):
self.create_purchased_job()
invoice = self.purchased_product.invoice
invoice.send_invoice_email(other_recipients=['*****@*****.**'])
old_email = mail.outbox.pop()
self.purchased_product.product.name = 'new name'
self.purchased_product.product.save()
invoice.send_invoice_email(other_recipients=['*****@*****.**'])
new_email = mail.outbox.pop()
self.assertEqual(old_email.body, new_email.body)
def test_productgrouping_add_delete(self):
self.create_purchased_job()
ProductGrouping.objects.create(display_title='Test Grouping',
explanation='Test Grouping',
name='Test Grouping',
owner=self.company)
self.assertEqual(ProductGrouping.objects.all().count(), 1)
grouping = ProductGrouping.objects.get()
order = ProductOrder.objects.create(product=self.product,
group=grouping)
grouping_products = grouping.products.all().values_list('pk', flat=True)
self.assertItemsEqual(grouping_products, [order.product.pk])
grouping.delete()
self.assertEqual(ProductGrouping.objects.all().count(), 0)
self.assertEqual(ProductOrder.objects.all().count(), 0)
def test_request_generation(self):
cu = CompanyUserFactory(user=self.user, company=self.company)
cu.make_purchased_microsite_admin()
self.create_purchased_job()
self.assertEqual(PurchasedJob.objects.all().count(), 1)
self.assertEqual(Request.objects.all().count(), 1)
self.assertEqual(len(mail.outbox), 1)
self.assertItemsEqual(mail.outbox[0].from_email,
'*****@*****.**')
mail.outbox = []
# Already approved jobs should not generate an additional request.
PurchasedJobFactory(
owner=self.company, created_by=self.user,
purchased_product=self.purchased_product, is_approved=True)
self.assertEqual(PurchasedJob.objects.all().count(), 2)
self.assertEqual(Request.objects.all().count(), 1)
self.assertEqual(len(mail.outbox), 0)
def test_offlinepurchase_create_purchased_products(self):
user = CompanyUserFactory(user=self.user, company=self.company)
offline_purchase = OfflinePurchaseFactory(
owner=self.company, created_by=user)
package = SitePackageFactory(owner=self.company)
product = ProductFactory(package=package, owner=self.company)
for x in range(1, 15):
PurchasedProduct.objects.all().delete()
OfflineProduct.objects.all().delete()
OfflineProductFactory(
product=product,
offline_purchase=offline_purchase,
product_quantity=x)
offline_purchase.create_purchased_products(self.company)
self.assertEqual(PurchasedProduct.objects.all().count(), x)
product_two = ProductFactory(package=package, owner=self.company)
for x in range(1, 15):
PurchasedProduct.objects.all().delete()
OfflineProduct.objects.all().delete()
OfflineProductFactory(product=product,
offline_purchase=offline_purchase,
product_quantity=x)
OfflineProductFactory(product=product_two,
offline_purchase=offline_purchase,
product_quantity=x)
offline_purchase.create_purchased_products(self.company)
self.assertEqual(PurchasedProduct.objects.all().count(), x*2)
def test_offlinepurchase_filter_by_sites(self):
cu = CompanyUserFactory(user=self.user, company=self.company)
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
product = ProductFactory(package=site_package, owner=self.company)
for y in range(1, 5):
purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=product,
offline_purchase=purchase)
count = OfflinePurchase.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
self.assertEqual(OfflinePurchase.objects.all().count(), 60)
def test_invoice_filter_by_sites(self):
cu = CompanyUserFactory(user=self.user, company=self.company)
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
product = ProductFactory(package=site_package, owner=self.company)
for y in range(1, 5):
# OfflinePurchaseFactory() automatically creates the invoice.
purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=product,
offline_purchase=purchase)
# Confirm it correctly picks up Invoices associated with
# OfflinePurchases.
self.assertEqual(Invoice.objects.filter_by_sites([site]).count(), 4)
for y in range(1, 5):
# PurchasedProductFactory() also automatically creates
# the invoice.
PurchasedProductFactory(product=product, owner=self.company)
# Confirm it correctly picks up Invoices associated with
# PurchasedProducts.
self.assertEqual(Invoice.objects.filter_by_sites([site]).count(), 8)
self.assertEqual(Invoice.objects.all().count(), 120)
def test_product_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
for y in range(1, 5):
ProductFactory(package=site_package, owner=self.company)
self.assertEqual(Product.objects.filter_by_sites([site]).count(), 4)
self.assertEqual(Product.objects.all().count(), 60)
def test_request_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
product = ProductFactory(package=site_package, owner=self.company)
purchased_product = PurchasedProductFactory(product=product,
owner=self.company)
for y in range(1, 5):
# Unapproved purchased jobs should create Requests.
PurchasedJobFactory(owner=self.company, created_by=self.user,
purchased_product=purchased_product)
self.assertEqual(Request.objects.filter_by_sites([site]).count(), 4)
self.assertEqual(Request.objects.all().count(), 60)
def test_purchasedproduct_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
for y in range(1, 5):
product = ProductFactory(package=site_package, owner=self.company)
PurchasedProductFactory(product=product, owner=self.company)
count = PurchasedProduct.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
self.assertEqual(PurchasedProduct.objects.all().count(), 60)
def test_job_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
for y in range(1, 5):
job = JobFactory(owner=self.company, created_by=self.user)
job.site_packages.add(site_package)
job.save()
self.assertEqual(Job.objects.filter_by_sites([site]).count(), 4)
self.assertEqual(Job.objects.all().count(), 60)
def test_purchasedjob_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
product = ProductFactory(package=site_package, owner=self.company)
purchased_product = PurchasedProductFactory(product=product,
owner=self.company)
for y in range(1, 5):
job = PurchasedJobFactory(owner=self.company,
created_by=self.user,
purchased_product=purchased_product)
job.site_packages.add(site_package)
job.save()
count = PurchasedJob.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
self.assertEqual(PurchasedJob.objects.all().count(), 60)
def test_productgrouping_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
site_package = SitePackageFactory(owner=self.company)
site_package.make_unique_for_site(site)
product = ProductFactory(package=site_package, owner=self.company)
for y in range(1, 5):
grouping = ProductGroupingFactory(owner=self.company,
display_order=y)
ProductOrder.objects.create(product=product, group=grouping,
display_order=y)
count = ProductGrouping.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
self.assertEqual(ProductGrouping.objects.all().count(), 60)
def test_sitepackage_filter_by_sites(self):
for x in range(8800, 8815):
domain = 'testsite-%s.jobs' % x
site = SeoSiteFactory(id=x, domain=domain, name=domain)
for y in range(1, 5):
site_package = SitePackageFactory(owner=self.company)
site_package.sites.add(site)
site_package.save()
count = SitePackage.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
count = Package.objects.filter_by_sites([site]).count()
self.assertEqual(count, 4)
self.assertEqual(SitePackage.objects.all().count(), 60)
self.assertEqual(Package.objects.all().count(), 60)
def test_product_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
ProductFactory(package=single_site_package, owner=self.company)
ProductFactory(package=both_sites_package, owner=self.company)
self.assertEqual(Product.objects.all().count(), 2)
# Confirm that filtering by both sites gets both jobs.
both_sites = [site_in_both_packages, self.site]
count = Product.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one job only
# gets one job.
count = Product.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
count = Product.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_job_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
job_on_both = JobFactory(owner=self.company, created_by=self.user)
job_on_both.site_packages.add(both_sites_package)
job_on_both.save()
job_on_new_site = JobFactory(owner=self.company, created_by=self.user)
job_on_new_site.site_packages.add(single_site_package)
job_on_new_site.save()
self.assertEqual(Job.objects.all().count(), 2)
# Confirm that filtering by both sites gets both jobs.
both_sites = [site_in_both_packages, self.site]
count = Job.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one job only
# gets one job.
self.assertEqual(Job.objects.filter_by_sites([self.site]).count(), 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
count = Job.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_purchasedproduct_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
PurchasedProductFactory(product=single_site_product, owner=self.company)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
PurchasedProductFactory(product=both_sites_product, owner=self.company)
self.assertEqual(PurchasedProduct.objects.all().count(), 2)
# Confirm that filtering by both sites gets both products.
both_sites = [site_in_both_packages, self.site]
count = PurchasedProduct.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one product only
# gets one product.
count = PurchasedProduct.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both products
# gets both jobs.
objs = PurchasedProduct.objects.filter_by_sites([site_in_both_packages])
count = objs.count()
self.assertEqual(count, 2)
def test_purchasedjob_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
single_site_purchasedproduct = PurchasedProductFactory(
product=single_site_product, owner=self.company)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
both_sites_purchasedproduct = PurchasedProductFactory(
product=both_sites_product, owner=self.company
)
PurchasedJobFactory(owner=self.company, created_by=self.user,
purchased_product=single_site_purchasedproduct)
PurchasedJobFactory(owner=self.company, created_by=self.user,
purchased_product=both_sites_purchasedproduct)
self.assertEqual(PurchasedJob.objects.all().count(), 2)
# Confirm that filtering by both sites gets both jobs.
both_sites = [site_in_both_packages, self.site]
count = PurchasedJob.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one job only
# gets one job.
count = PurchasedJob.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
objs = PurchasedJob.objects.filter_by_sites([site_in_both_packages])
count = objs.count()
self.assertEqual(count, 2)
def test_sitepackage_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
self.assertEqual(SitePackage.objects.all().count(), 2)
self.assertEqual(Package.objects.all().count(), 2)
# Confirm that filtering by both sites gets both packages.
both_sites = [site_in_both_packages, self.site]
count = SitePackage.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
count = Package.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one package only
# gets one package.
count = SitePackage.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
count = Package.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both packages
# gets both packages.
objs = SitePackage.objects.filter_by_sites([site_in_both_packages])
count = objs.count()
self.assertEqual(count, 2)
count = Package.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_productgrouping_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
single_site_grouping = ProductGroupingFactory(owner=self.company)
ProductOrder.objects.create(product=single_site_product,
group=single_site_grouping)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
both_sites_grouping = ProductGroupingFactory(owner=self.company)
ProductOrder.objects.create(product=both_sites_product,
group=both_sites_grouping)
# Confirm that filtering by both sites gets both groupings.
both_sites = [site_in_both_packages, self.site]
count = ProductGrouping.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one grouping only
# gets one grouping.
count = ProductGrouping.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
objs = ProductGrouping.objects.filter_by_sites([site_in_both_packages])
count = objs.count()
self.assertEqual(count, 2)
def test_offlinepurchase_filter_by_site_multiple_sites(self):
cu = CompanyUserFactory(user=self.user, company=self.company)
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
single_site_purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=single_site_product,
offline_purchase=single_site_purchase)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
both_sites_purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=both_sites_product,
offline_purchase=both_sites_purchase)
# Confirm that filtering by both sites gets both groupings.
both_sites = [site_in_both_packages, self.site]
count = OfflinePurchase.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one grouping only
# gets one grouping.
count = OfflinePurchase.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
objs = OfflinePurchase.objects.filter_by_sites([site_in_both_packages])
count = objs.count()
self.assertEqual(count, 2)
def test_invoice_from_offlinepurchase_filter_by_site_multiple_sites(self):
cu = CompanyUserFactory(user=self.user, company=self.company)
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
single_site_purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=single_site_product,
offline_purchase=single_site_purchase)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
both_sites_purchase = OfflinePurchaseFactory(owner=self.company, created_by=cu)
OfflineProduct.objects.create(product=both_sites_product,
offline_purchase=both_sites_purchase)
# Confirm that filtering by both sites gets both groupings.
both_sites = [site_in_both_packages, self.site]
count = Invoice.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one grouping only
# gets one grouping.
count = Invoice.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both jobs gets
# both jobs.
count = Invoice.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_invoice_from_purchasedproduct_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
PurchasedProductFactory(product=single_site_product, owner=self.company)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
PurchasedProductFactory(product=both_sites_product, owner=self.company)
self.assertEqual(Invoice.objects.all().count(), 2)
# Confirm that filtering by both sites gets both products.
both_sites = [site_in_both_packages, self.site]
count = Invoice.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one product only
# gets one product.
count = Invoice.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both products
# gets both jobs.
count = Invoice.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_request_filter_by_site_multiple_sites(self):
site_in_both_packages = SeoSiteFactory(domain='secondsite.jobs', id=7)
single_site_package = SitePackageFactory(owner=self.company)
single_site_package.make_unique_for_site(site_in_both_packages)
both_sites_package = SitePackageFactory(owner=self.company)
both_sites_package.sites.add(site_in_both_packages)
both_sites_package.sites.add(self.site)
both_sites_package.save()
single_site_product = ProductFactory(package=single_site_package, owner=self.company)
single_site_purchasedproduct = PurchasedProductFactory(
product=single_site_product, owner=self.company)
# Unapproved PurchasedJobs generate Requests.
PurchasedJobFactory(owner=self.company, created_by=self.user,
purchased_product=single_site_purchasedproduct)
both_sites_product = ProductFactory(package=both_sites_package, owner=self.company)
both_sites_purchasedproduct = PurchasedProductFactory(
product=both_sites_product, owner=self.company)
PurchasedJobFactory(owner=self.company, created_by=self.user,
purchased_product=both_sites_purchasedproduct)
self.assertEqual(Request.objects.all().count(), 2)
# Confirm that filtering by both sites gets both products.
both_sites = [site_in_both_packages, self.site]
count = Request.objects.filter_by_sites(both_sites).count()
self.assertEqual(count, 2)
# Confirm that filtering by the site that only has one product only
# gets one product.
count = Request.objects.filter_by_sites([self.site]).count()
self.assertEqual(count, 1)
# Confirm that filtering by the site the site that has both products
# gets both jobs.
count = Request.objects.filter_by_sites([site_in_both_packages]).count()
self.assertEqual(count, 2)
def test_request_on_purchasedjob_update(self):
# Creating a PurchasedJob for a Product that requires approval
# creates a Request
job = PurchasedJobFactory(owner=self.company, created_by=self.user)
self.assertEqual(Request.objects.count(), 1)
# Re-saving that job should not create a new request.
job.save()
self.assertEqual(Request.objects.count(), 1)
# Approving the job should also not create a new request.
job.is_approved = True
job.save()
self.assertEqual(Request.objects.count(), 1)
# Marking the job as not approved and saving it should not create
# a new request if no action was taken on the old request.
job.is_approved = False
job.save()
self.assertEqual(Request.objects.count(), 1)
# Marking the job as not approved and saving it should create
# a new request if there is no pending request.
request = Request.objects.get()
request.action_taken = True
request.save()
job.save()
self.assertEqual(Request.objects.count(), 2)
def setUp(self):
self.user = UserFactory()
self.company = CompanyFactory()
self.data = {'user': self.user.id,
'company': self.company.id}
class MyDashboardViewsTests(TestCase):
def setUp(self):
self.staff_user = UserFactory()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.staff_user.groups.add(group)
self.staff_user.save()
self.company = CompanyFactory()
self.company.save()
self.admin = CompanyUserFactory(user=self.staff_user,
company=self.company)
self.admin.save()
self.microsite = MicrositeFactory(company=self.company)
self.microsite.save()
self.client = TestClient()
self.client.login_user(self.staff_user)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
url='http://test.jobs/search?q=django',
label='test Jobs')
self.candidate_user.save()
for i in range(5):
# Create 5 new users
user = UserFactory(email='*****@*****.**' % i)
for search in SEARCH_OPTS:
# Create 15 new searches and assign three per user
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=%s' % search,
label='%s Jobs' % search)
def test_number_of_searches_and_users_is_correct(self):
response = self.client.post(
reverse('dashboard')+'?company='+str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
# 10 searches total, two rows per search
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
old_search = SavedSearch.objects.all()[0]
old_search.created_on -= timedelta(days=31)
old_search.save()
response = self.client.post(
reverse('dashboard')+'?company='+str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
# Tests to see if redirect from /candidates/ goes to candidates/view/
def test_redirect_to_candidates_views_default_page(self):
response = self.client.post('/candidates/')
# response returns HttpResponsePermanentRedirect which returns a 301
# status code instead of the normal 302 redirect status code
self.assertRedirects(response, '/candidates/view/', status_code=301,
target_status_code=200)
response = self.client.post(reverse('dashboard'))
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
company_name = soup.find('h1')
company_name = company_name.next
self.assertEqual(company_name, self.company.name)
# Eventually these opted-in/out will be changed to
# track if user is part of company's activity feed
def test_candidate_has_opted_in(self):
response = self.client.post(
reverse('candidate_information',
)+'?company='+str(self.company.id)+'&user='******'candidate_information',
)+'?company='+str(self.company.id)+'&user='******'candidate_information',
)+'?company='+str(self.company.id)+'&user='******'div', {'id': 'candidate-content'}).findAll(
'a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 6)
self.assertEqual(len(info), 16)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_with_activites(self):
response = self.client.post(
reverse('candidate_information',
)+'?company='+str(self.company.id)+'&user='******'div', {'id': 'candidate-content'}).findAll(
'a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 1)
self.assertEqual(len(info), 3)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_and_activites(self):
saved_search = SavedSearch.objects.get(user=self.candidate_user)
saved_search.delete()
response = self.client.post(
reverse('candidate_information',
)+'?company='+str(self.company.id)+'&user='******'div', {'id': 'candidate-content'})
self.assertFalse(info)
self.assertEqual(response.status_code, 404)
def test_export_csv(self):
response = self.client.post(
reverse('export_candidates')+'?company=' +
str(self.company.id)+'&ex-t=csv')
self.assertTrue(response.content)
self.assertEqual(response.status_code, 200)
def test_export_pdf(self):
response = self.client.post(
reverse('export_candidates')+'?company=' +
str(self.company.id)+'&ex-t=pdf')
self.assertTrue(response.content.index('PDF'))
self.assertEqual(response.templates[0].name,
'mydashboard/export/candidate_listing.html')
self.assertEqual(response.status_code, 200)
def test_export_xml(self):
response = self.client.post(
reverse('export_candidates')+'?company=' +
str(self.company.id)+'&ex-t=xml')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
def test_export_json(self):
response = self.client.post(
reverse('export_candidates')+'?company=' +
str(self.company.id)+'&ex-t=json')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
class MyDashboardViewsTests(TestCase):
def setUp(self):
self.staff_user = UserFactory()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.staff_user.groups.add(group)
self.staff_user.save()
self.company = CompanyFactory()
self.company.save()
self.admin = CompanyUserFactory(user=self.staff_user,
company=self.company)
self.admin.save()
self.microsite = MicrositeFactory(company=self.company)
self.microsite.save()
self.client = TestClient()
self.client.login_user(self.staff_user)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
url='http://test.jobs/search?q=django',
label='test Jobs')
self.candidate_user.save()
for i in range(5):
# Create 5 new users
user = UserFactory(email='*****@*****.**' % i)
for search in SEARCH_OPTS:
# Create 15 new searches and assign three per user
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=%s' % search,
label='%s Jobs' % search)
def test_number_of_searches_and_users_is_correct(self):
response = self.client.post(
reverse('dashboard') + '?company=' + str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
# 10 searches total, two rows per search
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
old_search = SavedSearch.objects.all()[0]
old_search.created_on -= timedelta(days=31)
old_search.save()
response = self.client.post(
reverse('dashboard') + '?company=' + str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
# Tests to see if redirect from /candidates/ goes to candidates/view/
def test_redirect_to_candidates_views_default_page(self):
response = self.client.post('/candidates/')
# response returns HttpResponsePermanentRedirect which returns a 301
# status code instead of the normal 302 redirect status code
self.assertRedirects(response,
'/candidates/view/',
status_code=301,
target_status_code=200)
response = self.client.post(reverse('dashboard'))
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
company_name = soup.find('h1')
company_name = company_name.next
self.assertEqual(company_name, self.company.name)
# Eventually these opted-in/out will be changed to
# track if user is part of company's activity feed
def test_candidate_has_opted_in(self):
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {
'id': 'candidate-content'
}).findAll('a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 6)
self.assertEqual(len(info), 16)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_with_activites(self):
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {
'id': 'candidate-content'
}).findAll('a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 1)
self.assertEqual(len(info), 3)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_and_activites(self):
saved_search = SavedSearch.objects.get(user=self.candidate_user)
saved_search.delete()
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {'id': 'candidate-content'})
self.assertFalse(info)
self.assertEqual(response.status_code, 404)
def test_export_csv(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=csv')
self.assertTrue(response.content)
self.assertEqual(response.status_code, 200)
def test_export_pdf(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=pdf')
self.assertTrue(response.content.index('PDF'))
self.assertEqual(response.templates[0].name,
'mydashboard/export/candidate_listing.html')
self.assertEqual(response.status_code, 200)
def test_export_xml(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=xml')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
def test_export_json(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=json')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
