def test_duplicate_company(self): company1 = CompanyFactory() company1.save() company2 = CompanyFactory(name="Acme corp") company2.save() self.businessunit.company_set.add(company1) self.businessunit.title = "Acme corp" add_company(self.businessunit) self.assertEqual(self.businessunit.company_set.all()[0], company2)
def test_subsidiary_rename(self): company1 = CompanyFactory() company1.save() bu1 = self.businessunit bu1.title = "Acme corp" bu2 = BusinessUnitFactory(title=bu1.title) bu2.save() self.businessunit.company_set.add(company1) # Test that a company was created for both business units add_company(bu1) companies = bu1.company_set.all() self.assertEqual(len(companies), 1) co = companies[0] self.assertEqual(co.name, bu1.title) # Add the 2nd business unit add_company(bu2) # Both units should be attached to that company self.assertEqual(bu1.company_set.all()[0], bu2.company_set.all()[0]) self.assertEqual(bu1.company_set.all().count(), 1) self.assertIn(bu1, co.job_source_ids.all()) self.assertIn(bu2, co.job_source_ids.all()) self.assertEqual(co.name, bu1.title) self.assertEqual(co.name, bu2.title) bu2.title = "New company name" add_company(bu1) add_company(bu2) self.assertEqual(len(co.job_source_ids.all()), 1) self.assertNotEqual(bu1.company_set.all(), bu2.company_set.all()) self.assertEqual(co.name, bu1.title) self.assertEqual(len(bu2.company_set.all()), 1) co2 = bu2.company_set.all()[0] self.assertEqual(co2.name, bu2.title) self.assertNotEqual(co2.name, bu1.title) self.assertNotEqual(co.name, bu2.title)
class TestContactsDataSource(MyJobsBase): 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 test_run_unfiltered(self): """ Make sure we only get data for this user. """ ds = ContactsDataSource() recs = ds.run_unaggregated(self.company, ContactsFilter(), []) names = {r['name'] for r in recs} expected = {self.sue.name, self.john.name} self.assertEqual(expected, names) def test_filter_by_date_range(self): """ Should show only contact with last_action_time in range. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(date=DateRangeFilter( [datetime(2015, 9, 1), datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_date_before(self): """ Should show only contact with last_action_time before date. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( date=DateRangeFilter([None, datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_date_after(self): """ Should show only contact with last_action_time after date. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( date=DateRangeFilter([datetime(2015, 10, 1), None])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_by_tags(self): """ Should show only contact with correct tags. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( tags=AndGroupFilter([OrGroupFilter([MatchFilter('EaSt')])])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_by_tags_or(self): """ Show only contact with correct tags in 'or' configuration. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter( [OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.john.name, self.sue.name} self.assertEqual(expected, names) def test_filter_by_tags_and(self): """ Show only contact with correct tags in 'and' configuration. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) names = {r['name'] for r in recs} expected = set() self.assertEqual(expected, names) # Now try adding another tag. self.john.tags.add(self.west_tag) recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_untagged(self): """ This indicates that the member selected to filter by untagged. """ self.sue.tags.clear() ds = ContactsDataSource() recs = ds.run_unaggregated(self.company, ContactsFilter(tags=UnlinkedFilter()), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_state(self): """Should show only contacts with correct state.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( locations=CompositeAndFilter({'state': MatchFilter('CA')})), []) names = [r['name'] for r in recs] expected = [self.sue.name] self.assertEqual(expected, names) def test_filter_by_city(self): """Should show only contacts with correct city.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(locations=CompositeAndFilter( {'city': MatchFilter('Los Angeles')})), []) names = [r['name'] for r in recs] expected = [self.sue.name] self.assertEqual(expected, names) def test_filter_by_partners(self): """Should filter by partners.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( partner=OrGroupFilter([MatchFilter(self.partner_a.pk)])), []) subjects = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, subjects) def test_filter_by_partner_tags(self): """ Test that we can filter by partner tags. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(partner_tags=AndGroupFilter( [OrGroupFilter([MatchFilter('rigHt')])])), []) subjects = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, subjects) def test_filter_by_partner_tags_untagged(self): """ Check that we can find a record attached to an untagged partner. """ self.partner_b.tags.clear() ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(partner_tags=UnlinkedFilter()), []) subjects = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, subjects) def test_help_city(self): """Check city help works and ignores current city filter.""" ds = ContactsDataSource() recs = ds.help_city( self.company, ContactsFilter(locations=CompositeAndFilter( {'city': MatchFilter('Los Angeles')})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """Check state help works and ignores current state filter.""" ds = ContactsDataSource() recs = ds.help_state( self.company, ContactsFilter( locations=CompositeAndFilter({'state': MatchFilter('zz')})), "i") actual = {r['value'] for r in recs} self.assertEqual({'IL', 'IN'}, actual) def test_help_tags(self): """Check tags help works at all.""" ds = ContactsDataSource() recs = ds.help_tags(self.company, ContactsFilter(), "E") actual = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_partner_tags(self): """ Check partner tags help works at all. """ ds = ContactsDataSource() recs = ds.help_partner_tags(self.company, ContactsFilter(), "t") actual = {r['value'] for r in recs} self.assertEqual({'left', 'right'}, actual) def test_help_tags_colors(self): """Tags should have colors""" ds = ContactsDataSource() recs = ds.help_tags(self.company, ContactsFilter(), "east") self.assertEqual("aaaaaa", recs[0]['hexColor']) def test_help_partner(self): """Check partner help works at all.""" ds = ContactsDataSource() recs = ds.help_partner(self.company, ContactsFilter(), "A") self.assertEqual([{ 'value': self.partner_a.pk, 'display': 'aaa' }], recs) def test_values(self): """Check limiting values works at all.""" ds = ContactsDataSource() recs = ds.run_unaggregated(self.company, ContactsFilter(), ["name", "email"]) expected = [ { 'name': self.john.name, 'email': u'*****@*****.**' }, { 'name': self.sue.name, 'email': u'*****@*****.**' }, ] self.assertEqual(expected, recs) def test_adorn_filter(self): self.maxDiff = 10000 found_filter_items = { 'tags': ['east', 'west'], 'partner': [str(self.partner_a.pk)], 'partner_tags': ['lEft', 'Right'], } expected = { u'partner': { self.partner_a.pk: { 'value': self.partner_a.pk, 'display': u'aaa' }, }, u'tags': { 'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, 'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, u'partner_tags': { 'left': { 'value': u'left', 'display': u'left', 'hexColor': u'cccccc', }, 'right': { 'value': u'right', 'display': u'right', 'hexColor': u'dddddd', }, }, } ds = ContactsDataSource() adorned_filter = ds.adorn_filter_items(self.company, found_filter_items) self.assertEqual(expected, adorned_filter) def test_default_filter(self): """should produce a populated filter object.""" ds = ContactsDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals(datetime.now().year, default_filter.date.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date.dates[1] = None expected = ContactsFilter( date=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)
class JobFeedTestCase(DirectSEOBase): def setUp(self): super(JobFeedTestCase, self).setUp() self.businessunit = BusinessUnitFactory(id=0) self.buid_id = self.businessunit.id self.numjobs = 14 self.testdir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'data') self.company = CompanyFactory() self.company.job_source_ids.add(self.businessunit) self.company.save() self.conn = Solr("http://127.0.0.1:8983/solr/seo") self.emptyfeed = os.path.join(self.testdir, "dseo_feed_0.no_jobs.xml") self.malformed_feed = os.path.join(self.testdir, 'dseo_malformed_feed_0.xml') self.invalid_feed = os.path.join(self.testdir, 'dseo_invalid_feed_0.xml') self.unused_field_feed = os.path.join(self.testdir, 'dseo_feed_1.xml') self.no_onet_feed = os.path.join(self.testdir, 'dseo_feed_no_onets.xml') #Ensures DATA_DIR used by import_jobs.download_feed_file exists data_path = DATA_DIR if not os.path.exists(data_path): os.mkdir(data_path) def test_company_canonical_microsite(self): # Test that canonical microsites is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertEqual(jobs[0]['company_canonical_microsite_exact'], None) self.company.canonical_microsite = "http://test.jobs" self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertEqual(jobs[0]['company_canonical_microsite_exact'], 'http://test.jobs') def test_company_enhanced(self): # Test that company enhanced check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_enhanced']) self.company.enhanced = True self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_enhanced']) def test_company_member(self): # Test that company member check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_member']) self.company.member = False self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_member']) def test_company_digital_strategies_customer(self): # Test that digial strategies customer check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_digital_strategies_customer']) self.company.digital_strategies_customer = True self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_digital_strategies_customer']) def test_no_markdown_newline_breaks(self): # Test that non-markdown businessunits have newlines converted to breaks no_markdown_bu = BusinessUnitFactory.build(id=5, enable_markdown=False) results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=no_markdown_bu.id, markdown=no_markdown_bu.enable_markdown) jobs = results.solr_jobs() self.assertNotEqual(jobs[0]['html_description'].find('Operations<br />'), -1) def test_markdown_no_newline_breaks(self): # Test that markdown businessunits do not have newlines converted to breaks results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, markdown = self.businessunit.enable_markdown) jobs = results.solr_jobs() self.assertEqual(jobs[0]['html_description'].find('Operations<br />'), -1) def test_unused_fields(self): # Test that new fields don't break existing code results = DEv2JobFeed(self.unused_field_feed, jsid=self.businessunit.id) jobs = results.solr_jobs() self.assertEqual(len(results.jobparse()), 1) def test_unescape(self): """Tests that escaped html characters are unescaped when imported""" results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.escaped_chars.xml', jsid=0) jobs = results.solr_jobs() self.assertEqual(results.job_source_name.find('¢'), -1) self.assertEqual(jobs[0]['description'].find('&'), -1) def test_markdown_code_blocks(self): #test that code blocks are not in html job descriptions results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.markdown.xml', jsid=0) jobs = results.solr_jobs() for job in jobs: self.assertEqual(job['html_description'].find('<code>'), -1) self.assertEqual(job['html_description'].find('</code>'), -1) self.assertEqual(job['html_description'].find('<pre>'), -1) self.assertEqual(job['html_description'].find('<h1>'), -1) self.assertEqual(job['html_description'].find('##'), -1) self.assertNotEqual(job['html_description'].find('<h4>'), -1) self.assertNotEqual(job['html_description'].find('<h6>'), -1) self.assertNotEqual(job['html_description'].find('<li>'), -1) self.assertNotEqual(job['html_description'].find('</li>'), -1) def test_no_null_values(self): # test that there's no literal null in html 'city' entry results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.markdown.xml', jsid=0) jobs = results.solr_jobs() for job in jobs: self.assertNotEqual(job['city'], 'null') def test_dev2_feed(self): filepath = download_feed_file(self.buid_id) results = DEv2JobFeed(filepath) jobs = results.jobparse() self.assertEqual(results.jsid, self.buid_id) self.assertEqual(results.job_source_name, self.businessunit.title) self.assertEqual(len(jobs), self.numjobs) def test_mocids(self): """ Tests that mocid fields exist when jobs are imported from a feed and added to a solr connnection """ filepath = download_feed_file(self.buid_id) results = DEv2JobFeed(filepath) jobs = results.solr_jobs() # Since we're going to be adding/updating data in the Solr index, we're # hardcoding in the local Solr instance so that we don't accidentally # alter production data. self.conn.add(jobs) num_hits = self.conn.search(q="*:*", fq="buid:%s -mocid:[* TO *]" % self.buid_id) self.assertEqual(num_hits.hits, self.numjobs) for job in jobs: self.assertTrue('mocid' in job) def test_empty_feed(self): """ Test that the schema for the v2 DirectEmployers feed file schema allows for empty feed files. """ results = DEv2JobFeed(self.emptyfeed) # If the schema is such that empty feed files are considered invalid, # trying to run jobparse() will throw an exception. self.assertEqual(len(results.jobparse()), 0) def test_empty_solr(self): """ Tests for the proper behavior when encountering a job-less, but otherwise valid, feed file. The proper behavior is to delete any jobs associated with that BusinessUnit from the Solr index. """ # Normal download-and-parse operation on a feed file with jobs. update_solr(self.buid_id) results = self.conn.search(q="*:*", fq="buid:%s" % self.buid_id) self.assertEqual(results.hits, self.numjobs) # Download-and-parse operation on a feed file with no jobs. Expected # behavior is to delete all jobs. self._get_feedfile() update_solr(self.buid_id, download=False) results = self.conn.search(q="*:*", fq="buid:%s" % self.buid_id) self.assertEqual(results.hits, 0) def test_zipcode(self): """ Tests to ensure proper behavior of zipcode field in being entered in Solr. """ filepath = download_feed_file(self.buid_id) dbresults = DEv2JobFeed(filepath) solrresults = dbresults.solr_jobs() zips_from_feedfile = ['30269', '30269', '48332', '30269', '30269', '30269', '30269', '30269', '48332', '48332', '30269', None, '30269', '30269'] solrzips = [i['zipcode'] for i in solrresults] for coll in [solrzips]: self.assertItemsEqual(zips_from_feedfile, coll) def test_salt_date(self): """ Test to ensure that job postings show up in a quasi-random fashion by sorting by the `salted_date` attribute in the index vice strictly by `date_new`. """ filepath = download_feed_file(self.buid_id) jobs = DEv2JobFeed(filepath) solrjobs = jobs.solr_jobs() self.conn.add(solrjobs) results = self.conn.search(q="*:*", sort="salted_date asc") self.assertEqual(self.numjobs, results.hits) # We can't really test for inequality between the two result sets, # since sometimes results.docs will equal results2.docs. results2 = self.conn.search(q="*:*", sort="date_new asc") self.assertItemsEqual(results2.docs, results.docs) def test_date_updated(self): """ Test to ensure proper behavior of date updated field when added to Solr. """ filepath = download_feed_file(self.buid_id) jobs = DEv2JobFeed(filepath) solrjobs = jobs.solr_jobs() self.conn.add(solrjobs) dates_updated = [datetime.datetime.strptime("4/16/2015 11:35:13 PM", "%m/%d/%Y %I:%M:%S %p"), datetime.datetime.strptime("4/16/2015 11:35:14 PM", "%m/%d/%Y %I:%M:%S %p"), datetime.datetime.strptime("4/16/2015 11:35:15 PM", "%m/%d/%Y %I:%M:%S %p")] solr_dates = [i['date_updated'] for i in solrjobs] for solr_date in solr_dates: self.assertIn(solr_date, dates_updated) def _get_feedfile(self): # Download the 'real' feed file then copy the empty feed file in its # place. realfeed = download_feed_file(self.buid_id) shutil.copyfile(realfeed, "%s.bak" % realfeed) shutil.copyfile(self.emptyfeed, realfeed) def test_parse_malformed_feed(self): """ Test that a malformed feedfile does not cause an unhandled exception. """ result = DEv2JobFeed(self.malformed_feed, jsid=0) def test_parse_invalid_feed(self): """ Test that a feed file that fails validation does not cause an unhandled exception. """ result = DEv2JobFeed(self.invalid_feed, jsid=0) def test_no_onets(self): result = DEv2JobFeed(self.no_onet_feed, jsid=0) jobs = result.solr_jobs() self.assertEqual(jobs[0]['onet'], '') def test_on_sites_by_buid(self): business_unit = BusinessUnitFactory(pk=77) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [0]) site_package = SitePackageFactory(owner=self.company) business_unit.site_packages.add(site_package) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [site_package.pk]) site_package2 = SitePackageFactory(owner=self.company) business_unit.site_packages.add(site_package2) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [site_package.pk, site_package2.pk]) site_package2.delete() site_package.delete() business_unit.delete()
class TestPasswordExpiration(TestCase): """Test password expiration""" def setUp(self): super(TestPasswordExpiration, self).setUp() (self.user, _) = User.objects.create_user(password='******', email='*****@*****.**') self.strict = CompanyFactory(password_expiration=True, name='strict') self.strict_role = RoleFactory(company=self.strict, name="Admin") self.loose = CompanyFactory(password_expiration=False, name='loose') self.loose_role = RoleFactory(company=self.loose, name="Admin") self.user.roles.add(self.strict_role) self.user.roles.add(self.loose_role) # Reload from db to get correct password state. self.user = User.objects.get(pk=self.user.pk) def test_no_company(self): """Users with no company should not have password expiration""" self.user.roles.clear() self.assertEqual(False, self.user.has_password_expiration()) self.assertEqual(False, self.user.is_password_expired()) self.user.password = '******' self.user.save() self.assertEqual(None, self.user.password_last_modified) self.assertEqual(0, self.user.userpasswordhistory_set.count()) def test_use_loose_companies_only(self): """Making the strict company loose should disable expiration.""" self.strict.password_expiration = False self.strict.save() self.assertEqual(False, self.user.has_password_expiration()) def test_use_stricter_company(self): """Users with any strict company should have password expiration""" self.assertEqual(True, self.user.has_password_expiration()) def test_first_expirable_login(self): """is_password_expired is True when the user has never logged in.""" self.assertEqual(True, self.user.is_password_expired()) def test_login_within_expire_window(self): """is_password_expired is False when in the expiration window.""" self.user.password_last_modified = (timezone.now() - datetime.timedelta(days=1)) self.user.save() self.assertEqual(False, self.user.is_password_expired()) def test_login_out_of_expire_window(self): """is_password_expired is True when past the expiration window.""" days = settings.PASSWORD_EXPIRATION_DAYS self.user.password_last_modified = (timezone.now() - datetime.timedelta(days)) self.user.save() self.assertEqual(True, self.user.is_password_expired()) def test_change_password(self): """ Changing password for a user in a company does sets pasword last modified time. """ before_password_set = timezone.now() self.user.set_password('somepass2') self.user.save() self.assertGreater(self.user.password_last_modified, before_password_set) self.assertEqual(1, self.user.userpasswordhistory_set.count()) def test_history_limit(self): """ Adding to the password history should exceed the history limit. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit + 2): date = (datetime.datetime(2016, 1, 1, tzinfo=pytz.UTC) + datetime.timedelta(days=i)) self.user.add_password_to_history('entry-%d' % i, date) self.assertLess(0, self.user.userpasswordhistory_set.count()) self.assertLessEqual(self.user.userpasswordhistory_set.count(), limit) hashes = set(h.password_hash for h in self.user.userpasswordhistory_set.all()) self.assertNotIn('entry-0', hashes) self.assertEquals(limit, len(hashes)) def test_is_password_in_history(self): """ Don't let the user reuse a password they used recently. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit + 1): self.user.set_password('entry-%d' % i) self.user.save() self.assertFalse(self.user.is_password_in_history('entry-0')) for i in range(1, limit + 1): entry = 'entry-%d' % i self.assertTrue(self.user.is_password_in_history(entry), entry) def test_is_password_in_history_disabled(self): """ Disable history checking if password expiration is off. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit): self.user.set_password('entry-%d' % i) self.user.save() self.strict.password_expiration = False self.strict.save() for i in range(0, limit): entry = 'entry-%d' % i self.assertFalse(self.user.is_password_in_history(entry), entry) def test_lockout_counter(self): """ Keep track of failed login attempts. """ limit = settings.PASSWORD_ATTEMPT_LOCKOUT for i in range(0, limit): self.assertFalse(self.user.is_locked_out(), 'iteration %d' % i) self.user.note_failed_login() self.assertTrue(self.user.is_locked_out()) self.user.reset_lockout() self.assertFalse(self.user.is_locked_out())
class TestPasswordExpiration(TestCase): """Test password expiration""" def setUp(self): super(TestPasswordExpiration, self).setUp() (self.user, _) = User.objects.create_user( password='******', email='*****@*****.**') self.strict = CompanyFactory(password_expiration=True, name='strict') self.strict_role = RoleFactory(company=self.strict, name="Admin") self.loose = CompanyFactory(password_expiration=False, name='loose') self.loose_role = RoleFactory(company=self.loose, name="Admin") self.user.roles.add(self.strict_role) self.user.roles.add(self.loose_role) # Reload from db to get correct password state. self.user = User.objects.get(pk=self.user.pk) def test_no_company(self): """Users with no company should not have password expiration""" self.user.roles.clear() self.assertEqual( False, self.user.has_password_expiration()) self.assertEqual( False, self.user.is_password_expired()) self.user.password = '******' self.user.save() self.assertEqual(None, self.user.password_last_modified) self.assertEqual(0, self.user.userpasswordhistory_set.count()) def test_use_loose_companies_only(self): """Making the strict company loose should disable expiration.""" self.strict.password_expiration = False self.strict.save() self.assertEqual(False, self.user.has_password_expiration()) def test_use_stricter_company(self): """Users with any strict company should have password expiration""" self.assertEqual(True, self.user.has_password_expiration()) def test_first_expirable_login(self): """is_password_expired is True when the user has never logged in.""" self.assertEqual(True, self.user.is_password_expired()) def test_login_within_expire_window(self): """is_password_expired is False when in the expiration window.""" self.user.password_last_modified = ( timezone.now() - datetime.timedelta(days=1)) self.user.save() self.assertEqual(False, self.user.is_password_expired()) def test_login_out_of_expire_window(self): """is_password_expired is True when past the expiration window.""" days = settings.PASSWORD_EXPIRATION_DAYS self.user.password_last_modified = ( timezone.now() - datetime.timedelta(days)) self.user.save() self.assertEqual(True, self.user.is_password_expired()) def test_change_password(self): """ Changing password for a user in a company does sets pasword last modified time. """ before_password_set = timezone.now() self.user.set_password('somepass2') self.user.save() self.assertGreater( self.user.password_last_modified, before_password_set) self.assertEqual(1, self.user.userpasswordhistory_set.count()) def test_history_limit(self): """ Adding to the password history should exceed the history limit. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit + 2): date = ( datetime.datetime(2016, 1, 1, tzinfo=pytz.UTC) + datetime.timedelta(days=i)) self.user.add_password_to_history('entry-%d' % i, date) self.assertLess(0, self.user.userpasswordhistory_set.count()) self.assertLessEqual( self.user.userpasswordhistory_set.count(), limit) hashes = set( h.password_hash for h in self.user.userpasswordhistory_set.all()) self.assertNotIn('entry-0', hashes) self.assertEquals(limit, len(hashes)) def test_is_password_in_history(self): """ Don't let the user reuse a password they used recently. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit + 1): self.user.set_password('entry-%d' % i) self.user.save() self.assertFalse(self.user.is_password_in_history('entry-0')) for i in range(1, limit + 1): entry = 'entry-%d' % i self.assertTrue(self.user.is_password_in_history(entry), entry) def test_is_password_in_history_disabled(self): """ Disable history checking if password expiration is off. """ limit = settings.PASSWORD_HISTORY_ENTRIES for i in range(0, limit): self.user.set_password('entry-%d' % i) self.user.save() self.strict.password_expiration = False self.strict.save() for i in range(0, limit): entry = 'entry-%d' % i self.assertFalse(self.user.is_password_in_history(entry), entry) def test_lockout_counter(self): """ Keep track of failed login attempts. """ limit = settings.PASSWORD_ATTEMPT_LOCKOUT for i in range(0, limit): self.assertFalse(self.user.is_locked_out(), 'iteration %d' % i) self.user.note_failed_login() self.assertTrue(self.user.is_locked_out()) self.user.reset_lockout() self.assertFalse(self.user.is_locked_out())
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(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() def test_run_unfiltered(self): """Make sure we only get data for this user.""" ds = CommRecordsDataSource() recs = ds.run_unaggregated(self.company, CommRecordsFilter(), []) subjects = {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() date_range = DateRangeFilter( [datetime(2015, 9, 1), datetime(2015, 9, 30)]) recs = ds.run_unaggregated(self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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() date_range = DateRangeFilter([None, datetime(2015, 9, 30)]) recs = ds.run_unaggregated(self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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() date_range = DateRangeFilter([datetime(2015, 10, 1), None]) recs = ds.run_unaggregated(self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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=CompositeAndFilter({'state': MatchFilter('CA')})), []) subjects = {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=CompositeAndFilter( {'city': MatchFilter('Los Angeles')})), []) subjects = {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=AndGroupFilter([OrGroupFilter([MatchFilter('EaSt')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.subject, self.record_2.subject} self.assertEqual(expected, subjects) def test_filter_by_tags_unlinked(self): """ Only return untagged commrecs. """ self.record_1.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated(self.company, CommRecordsFilter(tags=UnlinkedFilter()), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.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=AndGroupFilter( [OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) subjects = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) subjects = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.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=OrGroupFilter([MatchFilter('email')])), []) subjects = {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=OrGroupFilter([MatchFilter(self.partner_a.pk)])), []) subjects = {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=OrGroupFilter([MatchFilter(self.sue.pk)])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_contact_tags(self): """ Test that we can filter by contact tags. """ ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(contact_tags=AndGroupFilter( [OrGroupFilter([MatchFilter('sOuTh')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_contact_tags_untagged(self): """ Check that we can find a record attached to an untagged contact. """ self.sue.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(contact_tags=UnlinkedFilter()), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_partner_tags(self): """ Test that we can filter by partner tags. """ ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(partner_tags=AndGroupFilter( [OrGroupFilter([MatchFilter('rigHt')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_partner_tags_untagged(self): """ Check that we can find a record attached to an untagged partner. """ self.partner_b.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(partner_tags=UnlinkedFilter()), []) subjects = {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=CompositeAndFilter({'city': MatchFilter("zz")})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """ Check state help works and ignores current state filter. """ ds = CommRecordsDataSource() recs = ds.help_state( self.company, CommRecordsFilter( locations=CompositeAndFilter({'state': MatchFilter("zz")})), "i") actual = {r['value'] 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 = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_contact_tags(self): """ Check contact tags help works at all. """ ds = CommRecordsDataSource() recs = ds.help_contact_tags(self.company, CommRecordsFilter(), "O") actual = {r['value'] for r in recs} self.assertEqual({'north', 'south'}, actual) def test_help_partner_tags(self): """ Check partner tags help works at all. """ ds = CommRecordsDataSource() recs = ds.help_partner_tags(self.company, CommRecordsFilter(), "t") actual = {r['value'] for r in recs} self.assertEqual({'left', 'right'}, 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 = {r['value'] for r in recs} expected = {'phone', 'job', 'meetingorevent', 'email', 'pssemail'} self.assertEqual(expected, actual) def test_help_partner(self): """ Check partner help works at all. """ ds = CommRecordsDataSource() recs = ds.help_partner(self.company, CommRecordsFilter(), "A") self.assertEqual([{ 'value': 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([{ 'value': self.sue.pk, 'display': self.sue.name }], recs) def test_values(self): """ Check limiting values works at all """ self.maxDiff = 10000 ds = CommRecordsDataSource() recs = ds.run_unaggregated(self.company, CommRecordsFilter(), ["partner", "subject"]) expected = [ { 'partner': u'aaa', 'subject': u'record 1' }, { 'partner': u'aaa', 'subject': u'record 2' }, { 'partner': u'bbb', 'subject': u'record 3' }, ] self.assertEqual(expected, recs) def test_adorn_filter(self): self.maxDiff = 10000 found_filter_items = { 'tags': ['east', 'west'], 'communication_type': ['Email'], 'partner': [str(self.partner_a.pk)], 'contact': [str(self.sue.pk)], 'contact_tags': ['nOrth', 'south'], 'partner_tags': ['lEft', 'riGht'], } expected = { u'partner': { self.partner_a.pk: { 'value': self.partner_a.pk, 'display': u'aaa' }, }, u'contact': { self.sue.pk: { 'value': self.sue.pk, 'display': u'Sue Baxter' }, }, u'tags': { u'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, u'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, u'communication_type': { 'email': { 'value': 'email', 'display': 'Email' } }, u'contact_tags': { u'north': { 'value': u'north', 'display': u'north', 'hexColor': u'cccccc', }, u'south': { 'value': u'south', 'display': u'south', 'hexColor': u'dddddd', }, }, u'partner_tags': { u'left': { 'value': u'left', 'display': u'left', 'hexColor': u'eeeeee', }, u'right': { 'value': u'right', 'display': u'right', 'hexColor': u'ffffff', }, }, } ds = CommRecordsDataSource() result = ds.adorn_filter_items(self.company, found_filter_items) self.assertEqual(expected, result) def test_default_filter(self): """ should produce a populated filter object. """ ds = CommRecordsDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals(datetime.now().year, default_filter.date_time.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date_time.dates[1] = None expected = CommRecordsFilter( date_time=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)
class TestContactsDataSource(MyJobsBase): 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 test_run_unfiltered(self): """ Make sure we only get data for this user. """ ds = ContactsDataSource() recs = ds.run_unaggregated(self.company, ContactsFilter(), []) names = {r['name'] for r in recs} expected = {self.sue.name, self.john.name} self.assertEqual(expected, names) def test_filter_by_date_range(self): """ Should show only contact with last_action_time in range. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( date=DateRangeFilter([ datetime(2015, 9, 1), datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_date_before(self): """ Should show only contact with last_action_time before date. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( date=DateRangeFilter([None, datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_date_after(self): """ Should show only contact with last_action_time after date. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( date=DateRangeFilter([datetime(2015, 10, 1), None])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_by_tags(self): """ Should show only contact with correct tags. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')])])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_by_tags_or(self): """ Show only contact with correct tags in 'or' configuration. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.john.name, self.sue.name} self.assertEqual(expected, names) def test_filter_by_tags_and(self): """ Show only contact with correct tags in 'and' configuration. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = set() self.assertEqual(expected, names) # Now try adding another tag. self.john.tags.add(self.west_tag) recs = ds.run_unaggregated( self.company, ContactsFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, names) def test_filter_untagged(self): """ This indicates that the member selected to filter by untagged. """ self.sue.tags.clear() ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(tags=UnlinkedFilter()), []) names = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, names) def test_filter_by_state(self): """Should show only contacts with correct state.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( locations=CompositeAndFilter({'state': MatchFilter('CA')})), []) names = [r['name'] for r in recs] expected = [self.sue.name] self.assertEqual(expected, names) def test_filter_by_city(self): """Should show only contacts with correct city.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( locations=CompositeAndFilter({ 'city': MatchFilter('Los Angeles')})), []) names = [r['name'] for r in recs] expected = [self.sue.name] self.assertEqual(expected, names) def test_filter_by_partners(self): """Should filter by partners.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter( partner=OrGroupFilter([MatchFilter(self.partner_a.pk)])), []) subjects = {r['name'] for r in recs} expected = {self.john.name} self.assertEqual(expected, subjects) def test_filter_by_partner_tags(self): """ Test that we can filter by partner tags. """ ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(partner_tags=AndGroupFilter([ OrGroupFilter([MatchFilter('rigHt')])])), []) subjects = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, subjects) def test_filter_by_partner_tags_untagged(self): """ Check that we can find a record attached to an untagged partner. """ self.partner_b.tags.clear() ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(partner_tags=UnlinkedFilter()), []) subjects = {r['name'] for r in recs} expected = {self.sue.name} self.assertEqual(expected, subjects) def test_help_city(self): """Check city help works and ignores current city filter.""" ds = ContactsDataSource() recs = ds.help_city( self.company, ContactsFilter( locations=CompositeAndFilter({ 'city': MatchFilter('Los Angeles')})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """Check state help works and ignores current state filter.""" ds = ContactsDataSource() recs = ds.help_state( self.company, ContactsFilter( locations=CompositeAndFilter({ 'state': MatchFilter('zz')})), "i") actual = {r['value'] for r in recs} self.assertEqual({'IL', 'IN'}, actual) def test_help_tags(self): """Check tags help works at all.""" ds = ContactsDataSource() recs = ds.help_tags(self.company, ContactsFilter(), "E") actual = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_partner_tags(self): """ Check partner tags help works at all. """ ds = ContactsDataSource() recs = ds.help_partner_tags(self.company, ContactsFilter(), "t") actual = {r['value'] for r in recs} self.assertEqual({'left', 'right'}, actual) def test_help_tags_colors(self): """Tags should have colors""" ds = ContactsDataSource() recs = ds.help_tags(self.company, ContactsFilter(), "east") self.assertEqual("aaaaaa", recs[0]['hexColor']) def test_help_partner(self): """Check partner help works at all.""" ds = ContactsDataSource() recs = ds.help_partner(self.company, ContactsFilter(), "A") self.assertEqual( [{'value': self.partner_a.pk, 'display': 'aaa'}], recs) def test_values(self): """Check limiting values works at all.""" ds = ContactsDataSource() recs = ds.run_unaggregated( self.company, ContactsFilter(), ["name", "email"]) expected = [ {'name': self.john.name, 'email': u'*****@*****.**'}, {'name': self.sue.name, 'email': u'*****@*****.**'}, ] self.assertEqual(expected, recs) def test_adorn_filter(self): self.maxDiff = 10000 found_filter_items = { 'tags': ['east', 'west'], 'partner': [str(self.partner_a.pk)], 'partner_tags': ['lEft', 'Right'], } expected = { u'partner': { self.partner_a.pk: {'value': self.partner_a.pk, 'display': u'aaa'}, }, u'tags': { 'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, 'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, u'partner_tags': { 'left': { 'value': u'left', 'display': u'left', 'hexColor': u'cccccc', }, 'right': { 'value': u'right', 'display': u'right', 'hexColor': u'dddddd', }, }, } ds = ContactsDataSource() adorned_filter = ds.adorn_filter_items( self.company, found_filter_items) self.assertEqual(expected, adorned_filter) def test_default_filter(self): """should produce a populated filter object.""" ds = ContactsDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals( datetime.now().year, default_filter.date.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date.dates[1] = None expected = ContactsFilter( date=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)
class JobFeedTestCase(DirectSEOBase): def setUp(self): super(JobFeedTestCase, self).setUp() self.businessunit = BusinessUnitFactory(id=0) self.buid_id = self.businessunit.id self.numjobs = 14 self.testdir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'data') self.company = CompanyFactory() self.company.job_source_ids.add(self.businessunit) self.company.save() self.conn = Solr("http://127.0.0.1:8983/solr/seo") self.emptyfeed = os.path.join(self.testdir, "dseo_feed_0.no_jobs.xml") self.malformed_feed = os.path.join(self.testdir, 'dseo_malformed_feed_0.xml') self.invalid_feed = os.path.join(self.testdir, 'dseo_invalid_feed_0.xml') self.unused_field_feed = os.path.join(self.testdir, 'dseo_feed_1.xml') self.no_onet_feed = os.path.join(self.testdir, 'dseo_feed_no_onets.xml') # Ensures DATA_DIR used by import_jobs.download_feed_file exists data_path = DATA_DIR if not os.path.exists(data_path): os.mkdir(data_path) def test_company_canonical_microsite(self): # Test that canonical microsites is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertEqual(jobs[0]['company_canonical_microsite_exact'], None) self.company.canonical_microsite = "http://test.jobs" self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertEqual(jobs[0]['company_canonical_microsite_exact'], 'http://test.jobs') def test_company_enhanced(self): # Test that company enhanced check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_enhanced']) self.company.enhanced = True self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_enhanced']) def test_company_member(self): # Test that company member check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_member']) self.company.member = False self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_member']) def test_company_digital_strategies_customer(self): # Test that digial strategies customer check is correctly added to solr results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertFalse(jobs[0]['company_digital_strategies_customer']) self.company.digital_strategies_customer = True self.company.save() results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, company=self.businessunit.company_set.all()[0]) jobs = results.solr_jobs() self.assertTrue(jobs[0]['company_digital_strategies_customer']) def test_no_markdown_newline_breaks(self): # Test that non-markdown businessunits have newlines converted to breaks no_markdown_bu = BusinessUnitFactory.build(id=5, enable_markdown=False) results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=no_markdown_bu.id, markdown=no_markdown_bu.enable_markdown) jobs = results.solr_jobs() self.assertNotEqual(jobs[0]['html_description'].find('Operations<br />'), -1) def test_markdown_no_newline_breaks(self): # Test that markdown businessunits do not have newlines converted to breaks results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.xml', jsid=self.businessunit.id, markdown = self.businessunit.enable_markdown) jobs = results.solr_jobs() self.assertEqual(jobs[0]['html_description'].find('Operations<br />'), -1) def test_unused_fields(self): # Test that new fields don't break existing code results = DEv2JobFeed(self.unused_field_feed, jsid=self.businessunit.id) jobs = results.solr_jobs() self.assertEqual(len(results.jobparse()), 1) def test_unescape(self): """Tests that escaped html characters are unescaped when imported""" results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.escaped_chars.xml', jsid=0) jobs = results.solr_jobs() self.assertEqual(results.job_source_name.find('¢'), -1) self.assertEqual(jobs[0]['description'].find('&'), -1) def test_markdown_code_blocks(self): # test that code blocks are not in html job descriptions results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.markdown.xml', jsid=0) jobs = results.solr_jobs() for job in jobs: self.assertEqual(job['html_description'].find('<code>'), -1) self.assertEqual(job['html_description'].find('</code>'), -1) self.assertEqual(job['html_description'].find('<pre>'), -1) self.assertEqual(job['html_description'].find('<h1>'), -1) self.assertEqual(job['html_description'].find('##'), -1) self.assertNotEqual(job['html_description'].find('<h4>'), -1) self.assertNotEqual(job['html_description'].find('<h6>'), -1) self.assertNotEqual(job['html_description'].find('<li>'), -1) self.assertNotEqual(job['html_description'].find('</li>'), -1) def test_no_null_values(self): # test that there's no literal null in html 'city' entry results = DEv2JobFeed( 'seo/tests/data/dseo_feed_0.markdown.xml', jsid=0) jobs = results.solr_jobs() for job in jobs: self.assertNotEqual(job['city'], 'null') def test_dev2_feed(self): filepath = download_feed_file(self.buid_id) results = DEv2JobFeed(filepath) jobs = results.jobparse() self.assertEqual(results.jsid, self.buid_id) self.assertEqual(results.job_source_name, self.businessunit.title) self.assertEqual(len(jobs), self.numjobs) def test_mocids(self): """ Tests that mocid fields exist when jobs are imported from a feed and added to a solr connnection """ filepath = download_feed_file(self.buid_id) results = DEv2JobFeed(filepath) jobs = results.solr_jobs() # Since we're going to be adding/updating data in the Solr index, we're # hardcoding in the local Solr instance so that we don't accidentally # alter production data. self.conn.add(jobs) num_hits = self.conn.search(q="*:*", fq="buid:%s -mocid:[* TO *]" % self.buid_id) self.assertEqual(num_hits.hits, self.numjobs) for job in jobs: self.assertTrue('mocid' in job) def test_empty_feed(self): """ Test that the schema for the v2 DirectEmployers feed file schema allows for empty feed files. """ results = DEv2JobFeed(self.emptyfeed) # If the schema is such that empty feed files are considered invalid, # trying to run jobparse() will throw an exception. self.assertEqual(len(results.jobparse()), 0) def test_empty_solr(self): """ Tests for the proper behavior when encountering a job-less, but otherwise valid, feed file. The proper behavior is to delete any jobs associated with that BusinessUnit from the Solr index. """ # Normal download-and-parse operation on a feed file with jobs. update_solr(self.buid_id) results = self.conn.search(q="*:*", fq="buid:%s" % self.buid_id) self.assertEqual(results.hits, self.numjobs) # Download-and-parse operation on a feed file with no jobs. Expected # behavior is to delete all jobs. self._get_feedfile() update_solr(self.buid_id, download=False) results = self.conn.search(q="*:*", fq="buid:%s" % self.buid_id) self.assertEqual(results.hits, 0) def test_zipcode(self): """ Tests to ensure proper behavior of zipcode field in being entered in Solr. """ filepath = download_feed_file(self.buid_id) dbresults = DEv2JobFeed(filepath) solrresults = dbresults.solr_jobs() zips_from_feedfile = ['30269', '30269', '48332', '30269', '30269', '30269', '30269', '30269', '48332', '48332', '30269', None, '30269', '30269'] solrzips = [i['zipcode'] for i in solrresults] for coll in [solrzips]: self.assertItemsEqual(zips_from_feedfile, coll) def test_salt_date(self): """ Test to ensure that job postings show up in a quasi-random fashion by sorting by the `salted_date` attribute in the index vice strictly by `date_new`. """ filepath = download_feed_file(self.buid_id) jobs = DEv2JobFeed(filepath) solrjobs = jobs.solr_jobs() self.conn.add(solrjobs) results = self.conn.search(q="*:*", sort="salted_date asc") self.assertEqual(self.numjobs, results.hits) # We can't really test for inequality between the two result sets, # since sometimes results.docs will equal results2.docs. results2 = self.conn.search(q="*:*", sort="date_new asc") self.assertItemsEqual(results2.docs, results.docs) def test_date_updated(self): """ Test to ensure proper behavior of date updated field when added to Solr. """ filepath = download_feed_file(self.buid_id) jobs = DEv2JobFeed(filepath) solrjobs = jobs.solr_jobs() self.conn.add(solrjobs) dates_updated = [datetime.datetime.strptime("4/16/2015 11:35:13 PM", "%m/%d/%Y %I:%M:%S %p"), datetime.datetime.strptime("4/16/2015 11:35:14 PM", "%m/%d/%Y %I:%M:%S %p"), datetime.datetime.strptime("4/16/2015 11:35:15 PM", "%m/%d/%Y %I:%M:%S %p")] solr_dates = [i['date_updated'] for i in solrjobs] for solr_date in solr_dates: self.assertIn(solr_date, dates_updated) def _get_feedfile(self): # Download the 'real' feed file then copy the empty feed file in its # place. realfeed = download_feed_file(self.buid_id) shutil.copyfile(realfeed, "%s.bak" % realfeed) shutil.copyfile(self.emptyfeed, realfeed) def test_parse_malformed_feed(self): """ Test that a malformed feedfile does not cause an unhandled exception. """ result = DEv2JobFeed(self.malformed_feed, jsid=0) def test_parse_invalid_feed(self): """ Test that a feed file that fails validation does not cause an unhandled exception. """ result = DEv2JobFeed(self.invalid_feed, jsid=0) def test_no_onets(self): result = DEv2JobFeed(self.no_onet_feed, jsid=0) jobs = result.solr_jobs() self.assertEqual(jobs[0]['onet'], '') def test_on_sites_by_buid(self): business_unit = BusinessUnitFactory(pk=77) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [0]) site_package = SitePackageFactory(owner=self.company) business_unit.site_packages.add(site_package) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [site_package.pk]) site_package2 = SitePackageFactory(owner=self.company) business_unit.site_packages.add(site_package2) results = DEv2JobFeed('seo/tests/data/dseo_feed_0.xml', jsid=business_unit.id, markdown=business_unit.enable_markdown) jobs = results.solr_jobs() for job in jobs: self.assertItemsEqual(job['on_sites'], [site_package.pk, site_package2.pk]) site_package2.delete() site_package.delete() business_unit.delete()
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() #domain='buckconsoltants.jobs') 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_add_remove_job_locations(self): """ Regression test, job locations that were removed from a job weren't being removed from Solr Tests that adding or removing locations results in Solr updates after a job save """ locations = JobLocationFactory.create_batch(2) job = JobFactory(owner=self.company, created_by=self.user, locations=locations) self.assertEqual(self.ms_solr.search('*:*').hits, 2) guid = locations[0].guid job.locations.remove(locations[0]) self.assertEqual(self.ms_solr.search('guid:%s' % guid).hits, 0) self.assertEqual( self.ms_solr.search('guid:%s' % locations[1].guid).hits, 1) job.locations.remove(locations[1]) self.assertEqual(self.ms_solr.search('*:*').hits, 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) first = [] for x in range(1000, 1003): site = SeoSiteFactory(id=x, domain="%s.jobs" % x) package.sites.add(site) first.append(site.pk) self.assertItemsEqual(package.sites.all().values_list('id', flat=True), first) second = [self.site.pk] for x in range(100, 103): site = SeoSiteFactory(id=x, domain="%s.jobs" % x) site.business_units.add(self.bu) site.save() second.append(site.pk) # 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), second) 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_sent_to_specific_email(self): """ When `other_recipients` is specified, `send_invoice_email` should send invoices to those email addresses. """ 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. other_recipients = ['*****@*****.**', '*****@*****.**'] self.purchased_product.invoice.send_invoice_email( other_recipients=other_recipients) self.assertItemsEqual(mail.outbox[0].to, other_recipients) def test_invoice_sent_to_admins(self): """ When a company has postajob admins, invoices should be sent to each of them, unless the behavior is disabled by passing `send_to_admins=False`. """ 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 recipients are admins. role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.groups.add(group) self.purchased_product.invoice.send_invoice_email() self.assertItemsEqual(mail.outbox[0].to, [u'*****@*****.**']) self.assertItemsEqual(mail.outbox[0].from_email, '*****@*****.**') 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[1].to), 1) self.assertItemsEqual(mail.outbox[1].to, ['*****@*****.**']) def test_invoice_sent_to_admins_and_others(self): """ If a company has postajob admins and `other_recipients` is specified, emails should be sent to both groups. """ 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) role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.groups.add(group) 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, '*****@*****.**') 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): role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.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): role = RoleFactory(company=self.company) self.user.roles.add(role) offline_purchase = OfflinePurchaseFactory(owner=self.company, created_by=self.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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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=self.user) 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 test_enable_posting(self): """ Attempting to automatically enable posting for a company should result in a valid site package owned by that company. """ AppAccessFactory(name='Posting') company = CompanyFactory(name='Posting Company') site = SeoSite.objects.create(domain='somewhere.jobs') # sanity checks self.assertIsNone(site.canonical_company) self.assertEqual(company.enabled_access, []) package = enable_posting(company, site) # Django caches model instances company = Company.objects.get(pk=company.pk) site = SeoSite.objects.get(pk=site.pk) self.assertEqual(site.canonical_company, company) self.assertIn("Posting", company.enabled_access) self.assertIn(site, package.sites.all()) self.assertTrue( LoginBlock.objects.filter( name="Posting Company Login Block").exists()) def test_enable_marketplace(self): """ Attempting to automatically enable posting for a company should result in a valid site package owned by that company. """ AppAccessFactory(name='MarketPlace') company = CompanyFactory(name='Marketplace Company') site = SeoSite.objects.create(domain='somewhereelse.jobs') # sanity checks self.assertIsNone(site.canonical_company) self.assertEqual(company.enabled_access, []) package = enable_marketplace(company, site) # Django caches model instances company = Company.objects.get(pk=company.pk) site = SeoSite.objects.get(pk=site.pk) self.assertEqual(site.canonical_company, company) self.assertIn("MarketPlace", company.enabled_access) self.assertIn(site, package.sites.all()) self.assertTrue( LoginBlock.objects.filter( name="Marketplace Company Login Block").exists()) def test_create_login_block(self): """ Ensures that a login block is createed with the correct associations and a valid template. """ company = CompanyFactory(name='Marketplace Company') site = SeoSite.objects.create(domain='somewhereelse.jobs') template = raw_base_template(LoginBlock) response = self.client.get("/login", follow=True) login_block = create_login_block(company, site) # validate that the correct template was assigned to the login block self.assertEqual(login_block.template, template)
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()#domain='buckconsoltants.jobs') 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_add_remove_job_locations(self): """ Regression test, job locations that were removed from a job weren't being removed from Solr Tests that adding or removing locations results in Solr updates after a job save """ locations = JobLocationFactory.create_batch(2) job = JobFactory( owner=self.company, created_by=self.user, locations=locations) self.assertEqual(self.ms_solr.search('*:*').hits, 2) guid = locations[0].guid job.locations.remove(locations[0]) self.assertEqual(self.ms_solr.search('guid:%s' % guid).hits, 0) self.assertEqual(self.ms_solr.search('guid:%s' % locations[1].guid).hits, 1) job.locations.remove(locations[1]) self.assertEqual(self.ms_solr.search('*:*').hits, 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) first = [] for x in range(1000, 1003): site = SeoSiteFactory(id=x, domain="%s.jobs" % x) package.sites.add(site) first.append(site.pk) self.assertItemsEqual(package.sites.all().values_list('id', flat=True), first) second = [self.site.pk] for x in range(100, 103): site = SeoSiteFactory(id=x, domain="%s.jobs" % x) site.business_units.add(self.bu) site.save() second.append(site.pk) # 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), second) 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_sent_to_specific_email(self): """ When `other_recipients` is specified, `send_invoice_email` should send invoices to those email addresses. """ 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. other_recipients = ['*****@*****.**', '*****@*****.**'] self.purchased_product.invoice.send_invoice_email( other_recipients=other_recipients) self.assertItemsEqual(mail.outbox[0].to, other_recipients) def test_invoice_sent_to_admins(self): """ When a company has postajob admins, invoices should be sent to each of them, unless the behavior is disabled by passing `send_to_admins=False`. """ 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 recipients are admins. role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.groups.add(group) self.purchased_product.invoice.send_invoice_email() self.assertItemsEqual(mail.outbox[0].to, [u'*****@*****.**']) self.assertItemsEqual(mail.outbox[0].from_email, '*****@*****.**') 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[1].to), 1) self.assertItemsEqual(mail.outbox[1].to, ['*****@*****.**']) def test_invoice_sent_to_admins_and_others(self): """ If a company has postajob admins and `other_recipients` is specified, emails should be sent to both groups. """ 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) role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.groups.add(group) 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, '*****@*****.**') 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): role = RoleFactory(company=self.company) self.user.roles.add(role) self.user.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): role = RoleFactory(company=self.company) self.user.roles.add(role) offline_purchase = OfflinePurchaseFactory( owner=self.company, created_by=self.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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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=self.user) 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): role = RoleFactory(company=self.company) self.user.roles.add(role) 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=self.user) 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=self.user) 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 test_enable_posting(self): """ Attempting to automatically enable posting for a company should result in a valid site package owned by that company. """ AppAccessFactory(name='Posting') company = CompanyFactory(name='Posting Company') site = SeoSite.objects.create(domain='somewhere.jobs') # sanity checks self.assertIsNone(site.canonical_company) self.assertEqual(company.enabled_access, []) package = enable_posting(company, site) # Django caches model instances company = Company.objects.get(pk=company.pk) site = SeoSite.objects.get(pk=site.pk) self.assertEqual(site.canonical_company, company) self.assertIn("Posting", company.enabled_access) self.assertIn(site, package.sites.all()) self.assertTrue(LoginBlock.objects.filter( name="Posting Company Login Block").exists()) def test_enable_marketplace(self): """ Attempting to automatically enable posting for a company should result in a valid site package owned by that company. """ AppAccessFactory(name='MarketPlace') company = CompanyFactory(name='Marketplace Company') site = SeoSite.objects.create(domain='somewhereelse.jobs') # sanity checks self.assertIsNone(site.canonical_company) self.assertEqual(company.enabled_access, []) package = enable_marketplace(company, site) # Django caches model instances company = Company.objects.get(pk=company.pk) site = SeoSite.objects.get(pk=site.pk) self.assertEqual(site.canonical_company, company) self.assertIn("MarketPlace", company.enabled_access) self.assertIn(site, package.sites.all()) self.assertTrue(LoginBlock.objects.filter( name="Marketplace Company Login Block").exists()) def test_create_login_block(self): """ Ensures that a login block is createed with the correct associations and a valid template. """ company = CompanyFactory(name='Marketplace Company') site = SeoSite.objects.create(domain='somewhereelse.jobs') template = raw_base_template(LoginBlock) response = self.client.get("/login", follow=True) login_block = create_login_block(company, site) # validate that the correct template was assigned to the login block self.assertEqual(login_block.template, template)
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( 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() def test_run_unfiltered(self): """Make sure we only get data for this user.""" ds = CommRecordsDataSource() recs = ds.run_unaggregated(self.company, CommRecordsFilter(), []) subjects = {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() date_range = DateRangeFilter([ datetime(2015, 9, 1), datetime(2015, 9, 30)]) recs = ds.run_unaggregated( self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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() date_range = DateRangeFilter( [None, datetime(2015, 9, 30)]) recs = ds.run_unaggregated( self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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() date_range = DateRangeFilter( [datetime(2015, 10, 1), None]) recs = ds.run_unaggregated( self.company, CommRecordsFilter(date_time=date_range), []) subjects = {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=CompositeAndFilter({'state': MatchFilter('CA')})), []) subjects = {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=CompositeAndFilter({ 'city': MatchFilter('Los Angeles')})), []) subjects = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.subject, self.record_2.subject} self.assertEqual(expected, subjects) def test_filter_by_tags_unlinked(self): """ Only return untagged commrecs. """ self.record_1.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(tags=UnlinkedFilter()), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) subjects = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) subjects = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_1.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=OrGroupFilter([ MatchFilter('email')])), []) subjects = {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=OrGroupFilter([MatchFilter(self.partner_a.pk)])), []) subjects = {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=OrGroupFilter([MatchFilter(self.sue.pk)])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_contact_tags(self): """ Test that we can filter by contact tags. """ ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter( contact_tags=AndGroupFilter([ OrGroupFilter([MatchFilter('sOuTh')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_contact_tags_untagged(self): """ Check that we can find a record attached to an untagged contact. """ self.sue.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(contact_tags=UnlinkedFilter()), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_partner_tags(self): """ Test that we can filter by partner tags. """ ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter( partner_tags=AndGroupFilter([ OrGroupFilter([MatchFilter('rigHt')])])), []) subjects = {r['subject'] for r in recs} expected = {self.record_3.subject} self.assertEqual(expected, subjects) def test_filter_by_partner_tags_untagged(self): """ Check that we can find a record attached to an untagged partner. """ self.partner_b.tags.clear() ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(partner_tags=UnlinkedFilter()), []) subjects = {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=CompositeAndFilter({ 'city': MatchFilter("zz")})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """ Check state help works and ignores current state filter. """ ds = CommRecordsDataSource() recs = ds.help_state( self.company, CommRecordsFilter( locations=CompositeAndFilter({ 'state': MatchFilter("zz")})), "i") actual = {r['value'] 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 = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_contact_tags(self): """ Check contact tags help works at all. """ ds = CommRecordsDataSource() recs = ds.help_contact_tags(self.company, CommRecordsFilter(), "O") actual = {r['value'] for r in recs} self.assertEqual({'north', 'south'}, actual) def test_help_partner_tags(self): """ Check partner tags help works at all. """ ds = CommRecordsDataSource() recs = ds.help_partner_tags(self.company, CommRecordsFilter(), "t") actual = {r['value'] for r in recs} self.assertEqual({'left', 'right'}, 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 = {r['value'] for r in recs} expected = {'phone', 'job', 'meetingorevent', 'email', 'pssemail'} self.assertEqual(expected, actual) def test_help_partner(self): """ Check partner help works at all. """ ds = CommRecordsDataSource() recs = ds.help_partner(self.company, CommRecordsFilter(), "A") self.assertEqual( [{'value': 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( [{'value': self.sue.pk, 'display': self.sue.name}], recs) def test_values(self): """ Check limiting values works at all """ self.maxDiff = 10000 ds = CommRecordsDataSource() recs = ds.run_unaggregated( self.company, CommRecordsFilter(), ["partner", "subject"]) expected = [ {'partner': u'aaa', 'subject': u'record 1'}, {'partner': u'aaa', 'subject': u'record 2'}, {'partner': u'bbb', 'subject': u'record 3'}, ] self.assertEqual(expected, recs) def test_adorn_filter(self): self.maxDiff = 10000 found_filter_items = { 'tags': ['east', 'west'], 'communication_type': ['Email'], 'partner': [str(self.partner_a.pk)], 'contact': [str(self.sue.pk)], 'contact_tags': ['nOrth', 'south'], 'partner_tags': ['lEft', 'riGht'], } expected = { u'partner': { self.partner_a.pk: {'value': self.partner_a.pk, 'display': u'aaa'}, }, u'contact': { self.sue.pk: {'value': self.sue.pk, 'display': u'Sue Baxter'}, }, u'tags': { u'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, u'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, u'communication_type': { 'email': {'value': 'email', 'display': 'Email'} }, u'contact_tags': { u'north': { 'value': u'north', 'display': u'north', 'hexColor': u'cccccc', }, u'south': { 'value': u'south', 'display': u'south', 'hexColor': u'dddddd', }, }, u'partner_tags': { u'left': { 'value': u'left', 'display': u'left', 'hexColor': u'eeeeee', }, u'right': { 'value': u'right', 'display': u'right', 'hexColor': u'ffffff', }, }, } ds = CommRecordsDataSource() result = ds.adorn_filter_items(self.company, found_filter_items) self.assertEqual(expected, result) def test_default_filter(self): """ should produce a populated filter object. """ ds = CommRecordsDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals( datetime.now().year, default_filter.date_time.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date_time.dates[1] = None expected = CommRecordsFilter( date_time=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)
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(company=self.company, name='east', hex_color="aaaaaa") self.west_tag = TagFactory.create(company=self.company, name='west', hex_color="bbbbbb") self.bad_tag = TagFactory.create(company=self.company, 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 = {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(), []) data = [(r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs] expected = [ (self.partner_a.name, 2015, 1, 0), (self.partner_a.name, 2015, 2, 0), (self.partner_a.name, 2015, 3, 0), (self.partner_a.name, 2015, 4, 0), (self.partner_a.name, 2015, 5, 0), (self.partner_a.name, 2015, 6, 0), (self.partner_a.name, 2015, 7, 0), (self.partner_a.name, 2015, 8, 0), (self.partner_a.name, 2015, 9, 0), (self.partner_a.name, 2015, 10, 0), (self.partner_a.name, 2015, 11, 0), (self.partner_a.name, 2015, 12, 0), (self.partner_b.name, 2015, 1, 0), (self.partner_b.name, 2015, 2, 3), (self.partner_b.name, 2015, 3, 3), (self.partner_b.name, 2015, 4, 3), (self.partner_b.name, 2015, 5, 0), (self.partner_b.name, 2015, 6, 0), (self.partner_b.name, 2015, 7, 0), (self.partner_b.name, 2015, 8, 0), (self.partner_b.name, 2015, 9, 0), (self.partner_b.name, 2015, 10, 0), (self.partner_b.name, 2015, 11, 0), (self.partner_b.name, 2015, 12, 0), ] self.assertEqual(expected, data) def test_run_count_comm_rec_per_month_one_partner(self): """Trip over a bug in the mysql client driver.""" for (subject, itx) in enumerate(['a', 'b', 'c']): for year in [2013, 2015, 2014]: for month in [2, 3, 4]: self.sue.contactrecord_set.add( ContactRecordFactory(subject=subject, date_time=datetime( year, month, 1))) ds = PartnersDataSource() partners_filter = PartnersFilter( tags=AndGroupFilter([OrGroupFilter([MatchFilter('west')])])) recs = ds.run_count_comm_rec_per_month(self.company, partners_filter, ['name', 'year', '-month']) data = [(r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs] self.assertEqual(36, len(data)) def test_run_count_comm_rec_per_month_no_partners(self): """Trip over a bug in the mysql client driver.""" for (subject, itx) in enumerate(['a', 'b', 'c']): for month in [2, 3, 4]: self.sue.contactrecord_set.add( ContactRecordFactory(subject=subject, date_time=datetime(2015, month, 1))) ds = PartnersDataSource() partners_filter = PartnersFilter( tags=AndGroupFilter([OrGroupFilter([MatchFilter('zzz')])])) recs = ds.run_count_comm_rec_per_month(self.company, partners_filter, ['name', 'year', '-month']) self.assertEqual(0, len(recs)) def test_run_count_comm_rec_per_month_empty_partner(self): """One partner, no communication records.""" ds = PartnersDataSource() partners_filter = PartnersFilter( tags=AndGroupFilter([OrGroupFilter([MatchFilter('east')])])) recs = ds.run_count_comm_rec_per_month(self.company, partners_filter, ['name', 'year', '-month']) data = [(r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs] self.assertEqual(12, len(data)) default_year = datetime.now().year for item in data: self.assertEqual(default_year, item[1]) self.assertEqual(0, item[3]) def test_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=DateRangeFilter( [datetime(2015, 9, 1), datetime(2015, 9, 30)])), []) names = {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=DateRangeFilter([None, datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_date_after(self): """Should show only partner with last_action_time after date.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( date=DateRangeFilter([datetime(2015, 10, 1), None])), []) names = {r['name'] for r in recs} expected = {self.partner_b.name} self.assertEqual(expected, names) def test_filter_by_state(self): """Should show only partners with correct state.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( locations=CompositeAndFilter({ 'state': MatchFilter('CA'), })), []) names = [r['name'] for r in recs] expected = [self.partner_b.name] self.assertEqual(expected, names) def test_filter_by_city(self): """Should show only partners with correct city.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(locations=CompositeAndFilter({ 'city': MatchFilter('Los Angeles'), })), []) names = [r['name'] for r in recs] expected = [self.partner_b.name] self.assertEqual(expected, names) def test_filter_by_tags(self): """Show only partner with correct tags.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( tags=AndGroupFilter([OrGroupFilter([MatchFilter('EaSt')])])), []) names = {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=AndGroupFilter( [OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name, self.partner_b.name} self.assertEqual(expected, names) def test_filter_by_tags_and(self): """Show only partner with correct tags in 'and' configuration.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) names = {r['name'] for r in recs} expected = set() self.assertEqual(expected, names) # Now try adding another tag. self.partner_a.tags.add(self.west_tag) recs = ds.run_unaggregated( self.company, PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')]) ])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_data_source(self): """Check datasource filter works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(data_source=MatchFilter("zap")), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_uri(self): """Check uri filter works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(uri=MatchFilter("http://www.asdf.com/")), []) names = {r['name'] for r in recs} expected = {self.partner_b.name} self.assertEqual(expected, names) def test_help_city(self): """Check city help works and ignores current city filter.""" ds = PartnersDataSource() recs = ds.help_city( self.company, PartnersFilter( locations=CompositeAndFilter({'city': MatchFilter("zz")})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """Check state help works and ignores current state filter.""" ds = PartnersDataSource() recs = ds.help_state( self.company, PartnersFilter( locations=CompositeAndFilter({'state': MatchFilter("zz")})), "i") actual = {r['value'] for r in recs} self.assertEqual({'IL', 'IN'}, actual) def test_help_tags(self): """Check tags help works at all.""" ds = PartnersDataSource() recs = ds.help_tags(self.company, PartnersFilter(), "E") actual = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_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 = {r['value'] for r in recs} self.assertEqual({'http://www.example.com/'}, actual) def test_help_data_source(self): """Check data_source help works at all.""" ds = PartnersDataSource() recs = ds.help_data_source(self.company, PartnersFilter(), "z") actual = {r['value'] for r in recs} self.assertEqual({'zap'}, actual) def test_values(self): """Check limiting values works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated(self.company, PartnersFilter(), ["name", "uri"]) expected = [ { 'name': self.partner_a.name, 'uri': 'http://www.example.com/' }, { 'name': self.partner_b.name, 'uri': 'http://www.asdf.com/' }, ] self.assertEqual(expected, recs) def test_adorn_filter_items(self): found_filter_items = { 'tags': ['east', 'west'], 'uri': 'http://www.example.com/', } expected = { u'tags': { 'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, 'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, } ds = PartnersDataSource() adorned_filter = ds.adorn_filter_items(self.company, found_filter_items) self.assertEqual(expected, adorned_filter) def test_default_filter(self): """should produce a populated filter object.""" ds = PartnersDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals(datetime.now().year, default_filter.date.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date.dates[1] = None expected = PartnersFilter( date=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)
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( company=self.company, name='east', hex_color="aaaaaa") self.west_tag = TagFactory.create( company=self.company, name='west', hex_color="bbbbbb") self.bad_tag = TagFactory.create( company=self.company, 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 = {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(), []) data = [ (r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs ] expected = [ (self.partner_a.name, 2015, 1, 0), (self.partner_a.name, 2015, 2, 0), (self.partner_a.name, 2015, 3, 0), (self.partner_a.name, 2015, 4, 0), (self.partner_a.name, 2015, 5, 0), (self.partner_a.name, 2015, 6, 0), (self.partner_a.name, 2015, 7, 0), (self.partner_a.name, 2015, 8, 0), (self.partner_a.name, 2015, 9, 0), (self.partner_a.name, 2015, 10, 0), (self.partner_a.name, 2015, 11, 0), (self.partner_a.name, 2015, 12, 0), (self.partner_b.name, 2015, 1, 0), (self.partner_b.name, 2015, 2, 3), (self.partner_b.name, 2015, 3, 3), (self.partner_b.name, 2015, 4, 3), (self.partner_b.name, 2015, 5, 0), (self.partner_b.name, 2015, 6, 0), (self.partner_b.name, 2015, 7, 0), (self.partner_b.name, 2015, 8, 0), (self.partner_b.name, 2015, 9, 0), (self.partner_b.name, 2015, 10, 0), (self.partner_b.name, 2015, 11, 0), (self.partner_b.name, 2015, 12, 0), ] self.assertEqual(expected, data) def test_run_count_comm_rec_per_month_one_partner(self): """Trip over a bug in the mysql client driver.""" for (subject, itx) in enumerate(['a', 'b', 'c']): for year in [2013, 2015, 2014]: for month in [2, 3, 4]: self.sue.contactrecord_set.add( ContactRecordFactory( subject=subject, date_time=datetime(year, month, 1))) ds = PartnersDataSource() partners_filter = PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('west')])])) recs = ds.run_count_comm_rec_per_month( self.company, partners_filter, ['name', 'year', '-month']) data = [ (r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs ] self.assertEqual(36, len(data)) def test_run_count_comm_rec_per_month_no_partners(self): """Trip over a bug in the mysql client driver.""" for (subject, itx) in enumerate(['a', 'b', 'c']): for month in [2, 3, 4]: self.sue.contactrecord_set.add( ContactRecordFactory( subject=subject, date_time=datetime(2015, month, 1))) ds = PartnersDataSource() partners_filter = PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('zzz')])])) recs = ds.run_count_comm_rec_per_month( self.company, partners_filter, ['name', 'year', '-month']) self.assertEqual(0, len(recs)) def test_run_count_comm_rec_per_month_empty_partner(self): """One partner, no communication records.""" ds = PartnersDataSource() partners_filter = PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('east')])])) recs = ds.run_count_comm_rec_per_month( self.company, partners_filter, ['name', 'year', '-month']) data = [ (r['name'], r['year'], r['month'], r['comm_rec_count']) for r in recs ] self.assertEqual(12, len(data)) default_year = datetime.now().year for item in data: self.assertEqual(default_year, item[1]) self.assertEqual(0, item[3]) def test_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=DateRangeFilter( [datetime(2015, 9, 1), datetime(2015, 9, 30)])), []) names = {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=DateRangeFilter([None, datetime(2015, 9, 30)])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_date_after(self): """Should show only partner with last_action_time after date.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( date=DateRangeFilter([datetime(2015, 10, 1), None])), []) names = {r['name'] for r in recs} expected = {self.partner_b.name} self.assertEqual(expected, names) def test_filter_by_state(self): """Should show only partners with correct state.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( locations=CompositeAndFilter({ 'state': MatchFilter('CA'), })), []) names = [r['name'] for r in recs] expected = [self.partner_b.name] self.assertEqual(expected, names) def test_filter_by_city(self): """Should show only partners with correct city.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter( locations=CompositeAndFilter({ 'city': MatchFilter('Los Angeles'), })), []) names = [r['name'] for r in recs] expected = [self.partner_b.name] self.assertEqual(expected, names) def test_filter_by_tags(self): """Show only partner with correct tags.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')])])), []) names = {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=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt'), MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name, self.partner_b.name} self.assertEqual(expected, names) def test_filter_by_tags_and(self): """Show only partner with correct tags in 'and' configuration.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = set() self.assertEqual(expected, names) # Now try adding another tag. self.partner_a.tags.add(self.west_tag) recs = ds.run_unaggregated( self.company, PartnersFilter(tags=AndGroupFilter([ OrGroupFilter([MatchFilter('EaSt')]), OrGroupFilter([MatchFilter('wEsT')])])), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_data_source(self): """Check datasource filter works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(data_source=MatchFilter("zap")), []) names = {r['name'] for r in recs} expected = {self.partner_a.name} self.assertEqual(expected, names) def test_filter_by_uri(self): """Check uri filter works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(uri=MatchFilter("http://www.asdf.com/")), []) names = {r['name'] for r in recs} expected = {self.partner_b.name} self.assertEqual(expected, names) def test_help_city(self): """Check city help works and ignores current city filter.""" ds = PartnersDataSource() recs = ds.help_city( self.company, PartnersFilter(locations=CompositeAndFilter({ 'city': MatchFilter("zz")})), "angel") actual = {r['value'] for r in recs} self.assertEqual({'Los Angeles'}, actual) def test_help_state(self): """Check state help works and ignores current state filter.""" ds = PartnersDataSource() recs = ds.help_state( self.company, PartnersFilter(locations=CompositeAndFilter({ 'state': MatchFilter("zz")})), "i") actual = {r['value'] for r in recs} self.assertEqual({'IL', 'IN'}, actual) def test_help_tags(self): """Check tags help works at all.""" ds = PartnersDataSource() recs = ds.help_tags(self.company, PartnersFilter(), "E") actual = {r['value'] for r in recs} self.assertEqual({'east', 'west'}, actual) def test_help_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 = {r['value'] for r in recs} self.assertEqual({'http://www.example.com/'}, actual) def test_help_data_source(self): """Check data_source help works at all.""" ds = PartnersDataSource() recs = ds.help_data_source( self.company, PartnersFilter(), "z") actual = {r['value'] for r in recs} self.assertEqual({'zap'}, actual) def test_values(self): """Check limiting values works at all.""" ds = PartnersDataSource() recs = ds.run_unaggregated( self.company, PartnersFilter(), ["name", "uri"]) expected = [ {'name': self.partner_a.name, 'uri': 'http://www.example.com/'}, {'name': self.partner_b.name, 'uri': 'http://www.asdf.com/'}, ] self.assertEqual(expected, recs) def test_adorn_filter_items(self): found_filter_items = { 'tags': ['east', 'west'], 'uri': 'http://www.example.com/', } expected = { u'tags': { 'east': { 'value': u'east', 'display': u'east', 'hexColor': u'aaaaaa', }, 'west': { 'value': u'west', 'display': u'west', 'hexColor': u'bbbbbb', }, }, } ds = PartnersDataSource() adorned_filter = ds.adorn_filter_items( self.company, found_filter_items) self.assertEqual(expected, adorned_filter) def test_default_filter(self): """should produce a populated filter object.""" ds = PartnersDataSource() default_filter = ds.get_default_filter(None, self.company) self.assertEquals( datetime.now().year, default_filter.date.dates[1].year) # Take out value dated today. Too hard to run through assertEquals. default_filter.date.dates[1] = None expected = PartnersFilter( date=DateRangeFilter([datetime(2014, 1, 1), None])) self.assertEquals(expected, default_filter)