def test_office_as_json(self):
# Create office
office = Office(
siret='00000000000001',
company_name='1',
headcount='11',
city_code='57070',
zipcode='57070',
naf='7320Z',
score=90,
x=6.166667,
y=49.133333,
score_alternance=80,
)
office.distance = 10
office_json = office.as_json()
self.assertEqual(office.siret, office_json['siret'])
self.assertEqual(office.company_name, office_json['name'])
self.assertEqual(settings.HEADCOUNT_INSEE[office.headcount],
office_json['headcount_text'])
self.assertEqual(office.x, office_json['lon'])
self.assertEqual(office.y, office_json['lat'])
self.assertEqual(office.naf, office_json['naf'])
self.assertEqual(office.distance, office_json['distance'])
self.assertTrue(office_json['alternance'])
def test_update_offices_geolocations(self):
"""
Test `update_offices_geolocations`.
"""
# Add an entry in the OfficeAdminExtraGeoLocation table with extra geolocations.
extra_geolocation = OfficeAdminExtraGeoLocation(
siret=self.office1.siret,
codes="75110\n13055", # Paris 10 + Marseille
)
extra_geolocation.save(commit=True)
script.update_offices_geolocations()
# The office should now have 3 geolocations in ES (the original one + Paris 10 + Marseille).
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=self.office1.siret)
expected_locations = [
{
'lat': 43.25996690043557,
'lon': 5.370740865779022
},
{
'lat': 48.8815994262695,
'lon': 2.36229991912841
},
{
'lat': 49.1044,
'lon': 6.17952
},
]
self.assertEqual(
sorted(res['_source']['locations'],
key=lambda x: (x['lat'], x['lon'])), expected_locations)
office = Office.get(self.office1.siret)
self.assertTrue(office.has_multi_geolocations)
# Make `extra_geolocation` instance out-of-date.
extra_geolocation.date_end = datetime.datetime.now(
) - datetime.timedelta(days=1)
extra_geolocation.update()
self.assertTrue(extra_geolocation.is_outdated())
script.update_offices_geolocations()
# The office extra geolocations should now be reset.
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=self.office1.siret)
expected_locations = [
{
'lat': 49.1044,
'lon': 6.17952
},
]
self.assertEqual(res['_source']['locations'], expected_locations)
office = Office.get(self.office1.siret)
self.assertFalse(office.has_multi_geolocations)
def setUp(self):
"""
Populate the DB with data required for these tests to work.
"""
super(UserAccountTest, self).setUp()
self.user = User(email='*****@*****.**',
gender='male',
first_name='John',
last_name='Doe')
db_session.add(self.user)
db_session.flush()
self.office1 = Office(
departement='57',
siret='00000000000001',
company_name='1',
headcount='5',
city_code='57070',
zipcode='57070',
naf='4646Z',
score=90,
x=6.166667,
y=49.133333,
)
self.office2 = Office(
departement='57',
siret='00000000000002',
company_name='1',
headcount='5',
city_code='57070',
zipcode='57070',
naf='4646Z',
score=90,
x=6.166667,
y=49.133333,
)
db_session.add_all([self.office1, self.office2])
db_session.flush()
self.user_social_auth = UserSocialAuth(
provider=PEAMOpenIdConnect.name,
extra_data={'id_token': 'fake'},
user_id=self.user.id,
)
self.fav1 = UserFavoriteOffice(user_id=self.user.id,
office_siret=self.office1.siret)
self.fav2 = UserFavoriteOffice(user_id=self.user.id,
office_siret=self.office2.siret)
db_session.add_all([self.user_social_auth, self.fav1, self.fav2])
db_session.flush()
db_session.commit()
self.assertEqual(db_session.query(User).count(), 1)
self.assertEqual(db_session.query(Office).count(), 2)
self.assertEqual(db_session.query(UserFavoriteOffice).count(), 2)
self.assertEqual(db_session.query(UserSocialAuth).count(), 1)
class CreateIndexBaseTest(DatabaseTest):
"""
Create Elasticsearch and DB content for the unit tests.
"""
def setUp(self, *args, **kwargs):
super(CreateIndexBaseTest, self).setUp(*args, **kwargs)
# Create 1 office.
self.office = Office(
siret=u"78548035101646",
company_name=u"SUPERMARCHES MATCH",
office_name=u"SUPERMARCHES MATCH",
naf=u"4711D",
street_number=u"45",
street_name=u"AVENUE ANDRE MALRAUX",
city_code=u"57463",
zipcode=u"57000",
email=u"*****@*****.**",
tel=u"0387787878",
website=u"http://www.supermarchesmatch.fr",
flag_alternance=0,
flag_junior=0,
flag_senior=0,
flag_handicap=0,
departement=u"57",
headcount=u"12",
score=50,
x=6.17952,
y=49.1044,
)
self.office.save()
# We should have 1 office in the DB.
self.assertEquals(Office.query.count(), 1)
# Put the office into ES.
script.create_offices(index=self.ES_TEST_INDEX)
time.sleep(1) # Sleep required by ES to register new documents.
# We should have 1 office in the ES.
count = self.es.count(index=self.ES_TEST_INDEX,
doc_type=self.ES_OFFICE_TYPE,
body={'query': {
'match_all': {}
}})
self.assertEquals(count['count'], 1)
# Ensure that the office is the one that has been indexed in ES.
res = self.es.get(index=self.ES_TEST_INDEX,
doc_type=self.ES_OFFICE_TYPE,
id=self.office.siret)
self.assertEquals(res['_source']['email'], self.office.email)
def tearDown(self):
script.drop_and_create_index(index=self.ES_TEST_INDEX)
return super(CreateIndexBaseTest, self).tearDown()
def make_geocoded_office():
office = Office(
siret=1234,
street_number="30",
street_name="rue Edouard Poisson",
zipcode="93300",
city_code="93001",
x=1.1,
y=1.1,
headcount="11",
)
office.save()
def test_update_office_with_blank_new_name_companny_office(self):
"""
Test `update_offices` to update an office: update names, email and website, keep current phone.
"""
office = Office.get(self.office1.siret)
old_company_name = office.company_name
old_office_name = office.office_name
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.name,
new_company_name="",
new_office_name="",
boost=True,
new_email="*****@*****.**",
new_phone="", # Leave empty on purpose: it should not be modified.
new_website="https://foo.pole-emploi.fr",
remove_email=False,
remove_phone=False,
remove_website=False,
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
office = Office.get(self.office1.siret)
self.assertEqual(office.company_name, old_office_name)
self.assertEqual(office.office_name, old_office_name)
self.assertEqual(office.email, office_to_update.new_email)
self.assertEqual(office.score,
office.score) # This value should not be modified.
self.assertEqual(
office.tel, self.office1.tel) # This value should not be modified.
self.assertEqual(office.website, office_to_update.new_website)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office.siret)
self.assertEqual(res['_source']['email'], office.email)
self.assertEqual(res['_source']['phone'], office.tel)
self.assertEqual(res['_source']['website'], office.website)
# Global score should always be the same.
self.assertEqual(res['_source']['score'], office.score)
# Check scores for ROME.
# Since `romes_to_boost` is empty, all romes should be boosted.
self.assertEqual(office_to_update.romes_to_boost, "")
for rome in mapping_util.romes_for_naf(office.naf):
self.assertTrue(res['_source']['boosted_romes'][rome.code])
def test_remove_contacts_multi_siret(self):
sirets = [self.office1.siret, self.office2.siret]
office_to_update = OfficeAdminUpdate(
sirets='\n'.join(sirets),
name="Supermarché",
remove_email=True,
remove_phone=True,
remove_website=True,
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
for siret in sirets:
office = Office.get(siret)
self.assertEqual(office.email, '')
self.assertEqual(office.tel, '')
self.assertEqual(office.website, '')
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=siret)
self.assertEqual(res['_source']['email'], '')
self.assertEqual(res['_source']['phone'], '')
self.assertEqual(res['_source']['website'], '')
def create_example_office(self):
# Create an office.
self.office = Office(
departement=u'75',
siret=u'78548035101646',
company_name=u'NICOLAS',
headcount=u'03',
city_code=u'75110',
zipcode=u'75010',
naf=u'7320Z',
tel=u'0100000000',
score=80,
x=2.3488,
y=48.8534,
)
self.office.save()
def test_update_office_by_removing_contact(self):
"""
Test `update_offices` to update an office: remove email, phone and website.
"""
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
new_email=
"*****@*****.**", # Should be overriden by remove_email.
new_website=
"https://foo.pole-emploi.fr", # Should be overriden by remove_website.
remove_email=True,
remove_phone=True,
remove_website=True,
new_company_name="",
new_office_name="",
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
office = Office.get(self.office1.siret)
self.assertEqual(office.email, '')
self.assertEqual(office.tel, '')
self.assertEqual(office.website, '')
# Names should still be the same.
self.assertEqual(office.company_name, self.office1.company_name)
self.assertEqual(office.office_name, self.office1.office_name)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office.siret)
self.assertEqual(res['_source']['email'], '')
self.assertEqual(res['_source']['phone'], '')
self.assertEqual(res['_source']['website'], '')
def cookbook():
office = Office(company_name='Nom SAS',
siret='0000000000001',
city_code='75056',
naf='0111Z',
score=3)
return render_template('root/cookbook.html', company=office)
def test_update_office_by_removing_contact(self):
"""
Test `update_offices` to update an office: remove email, phone and website.
"""
office_to_update = OfficeAdminUpdate(
siret=self.office.siret,
name=self.office.company_name,
new_email=
u"*****@*****.**", # Should be overriden by remove_email.
new_website=
u"https://foo.pole-emploi.fr", # Should be overriden by remove_website.
remove_email=True,
remove_phone=True,
remove_website=True,
)
office_to_update.save()
script.update_offices(index=self.ES_TEST_INDEX)
time.sleep(1) # Sleep required by ES to register new documents.
office = Office.get(self.office.siret)
self.assertEquals(office.email, u'')
self.assertEquals(office.tel, u'')
self.assertEquals(office.website, u'')
res = self.es.get(index=self.ES_TEST_INDEX,
doc_type=self.ES_OFFICE_TYPE,
id=office.siret)
self.assertEquals(res['_source']['email'], u'')
self.assertEquals(res['_source']['phone'], u'')
self.assertEquals(res['_source']['website'], u'')
self.assertEquals(res['_source']['score'], self.office.score)
def test_update_office_by_updating_contact(self):
"""
Test `update_offices` to update an office: update email and website, keep current phone.
"""
office_to_update = OfficeAdminUpdate(
siret=self.office.siret,
name=self.office.company_name,
new_score=100,
new_email=u"*****@*****.**",
new_phone=u"", # Leave empty on purpose: it should not be modified.
new_website=u"https://foo.pole-emploi.fr",
remove_email=False,
remove_phone=False,
remove_website=False,
)
office_to_update.save()
script.update_offices(index=self.ES_TEST_INDEX)
time.sleep(1) # Sleep required by ES to register new documents.
office = Office.get(self.office.siret)
self.assertEquals(office.email, office_to_update.new_email)
self.assertEquals(office.score, office_to_update.new_score)
self.assertEquals(
office.tel, self.office.tel) # This value should not be modified.
self.assertEquals(office.website, office_to_update.new_website)
res = self.es.get(index=self.ES_TEST_INDEX,
doc_type=self.ES_OFFICE_TYPE,
id=office.siret)
self.assertEquals(res['_source']['email'], office.email)
self.assertEquals(res['_source']['phone'], office.tel)
self.assertEquals(res['_source']['score'], office.score)
self.assertEquals(res['_source']['website'], office.website)
def test_update_office_boost_specific_romes(self):
"""
Test `update_offices` to update an office: boost score for specific ROME codes.
"""
romes_for_office = [
rome.code for rome in mapping_util.romes_for_naf(self.office1.naf)
]
# Ensure the following ROME codes are related to the office.
self.assertIn("D1507", romes_for_office)
self.assertIn("D1103", romes_for_office)
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
boost=True,
romes_to_boost="D1507\nD1103", # Boost score only for those ROME.
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
office = Office.get(self.office1.siret)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office.siret)
# Check boosted scores.
self.assertEqual({
'D1507': True,
'D1103': True,
}, res['_source']['boosted_romes'])
def test_update_office_removed_romes(self):
"""
Test `update_offices` to update an office: remove specific ROME to an office
"""
romes_for_office = [
rome.code for rome in mapping_util.romes_for_naf(self.office1.naf)
]
self.assertIn("D1101", romes_for_office) # Rome related to the office
self.assertIn("D1507", romes_for_office) # Rome related to the office
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
boost=False,
romes_to_boost='',
romes_to_remove="D1507", # Remove score only for those ROME.
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
office = Office.get(self.office1.siret)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office.siret)
# Check rome scores.
self.assertIn('D1101', res['_source']['scores_by_rome'])
self.assertNotIn('D1507', res['_source']['scores_by_rome'])
# Other scores should not be boosted.
for rome in romes_for_office:
if rome != "D1507":
self.assertNotIn(rome, res['_source']['boosted_romes'])
def test_new_contact_multi_siret(self):
sirets = [self.office1.siret, self.office2.siret]
office_to_update = OfficeAdminUpdate(
sirets='\n'.join(sirets),
name="Supermarchés",
new_email="*****@*****.**",
new_phone="0240656459",
new_website="https://foo.pole-emploi.fr",
remove_email=False,
remove_phone=False,
remove_website=False,
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
for siret in sirets:
office = Office.get(siret)
self.assertEqual(office.email, office_to_update.new_email)
self.assertEqual(office.tel, office_to_update.new_phone)
self.assertEqual(office.website, office_to_update.new_website)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=siret)
self.assertEqual(res['_source']['email'],
office_to_update.new_email)
self.assertEqual(res['_source']['phone'],
office_to_update.new_phone)
self.assertEqual(res['_source']['website'],
office_to_update.new_website)
def test_update_office_boost_unrelated_romes(self):
"""
Test `update_offices` to update an office: boost score for specific ROME codes
but with romes not associated to the office.
"""
romes_for_office = [rome.code for rome in mapping_util.romes_for_naf(self.office1.naf)]
self.assertNotIn("D1506", romes_for_office) # Rome not related to the office
self.assertIn("D1507", romes_for_office) # Rome related to the office
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
boost=True,
romes_to_boost="D1506\nD1507", # Boost score only for those ROME.
)
office_to_update.save()
script.update_offices()
office = Office.get(self.office1.siret)
res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret)
# Check boosted scores.
self.assertTrue(res['_source']['boosted_romes']['D1506'])
self.assertTrue(res['_source']['boosted_romes']['D1507'])
# Other scores should not be boosted.
for rome in romes_for_office:
if rome != "D1507":
self.assertNotIn(rome, res['_source']['boosted_romes'])
def test_update_office_add_alternance_infos(self):
"""
Test `update_offices` to add an email for alternance
"""
office = Office.get(self.office1.siret)
self.assertNotEqual(office.email_alternance, "*****@*****.**")
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
email_alternance="*****@*****.**",
phone_alternance="0699999999",
website_alternance="http://example-alternance.com",
)
office_to_update.save(commit=True)
script.update_offices()
office = Office.get(self.office1.siret)
self.assertEqual(office.email_alternance, "*****@*****.**")
self.assertEqual(office.phone_alternance, "0699999999")
self.assertEqual(office.website_alternance, "http://example-alternance.com")
def setUp(self):
super().setUp()
# Create an office.
self.office = Office(
departement='75',
siret='78548035101646',
company_name='NICOLAS',
headcount='03',
city_code='75110',
zipcode='75010',
naf='4646Z',
tel='0100000000',
score=80,
x=2.3488,
y=48.8534,
)
self.office.save()
# Remove pdf file if it already exists
pdf.delete_file(self.office)
def test_update_office_remove_on_lbb(self):
"""
Test `update_offices` to hide on lbb
"""
# Remove for this company
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
score=0,
)
office = Office.get(self.office1.siret)
self.assertNotEqual(office.score, 0)
office_to_update.save(commit=True)
script.update_offices(OfficeAdminUpdate)
# Expected score_rome = 0
office = Office.get(self.office1.siret)
self.assertEqual(office.score, 0)
def inject_dict_for_all_templates():
return {
'memo_url': settings.MEMO_URL,
'user_is_pro': pro.user_is_pro(),
'pro_version_enabled': pro.pro_version_enabled(),
'last_data_deploy_date': Office.get_date_of_last_data_deploy(),
'google_site_verification_code':
settings.GOOGLE_SITE_VERIFICATION_CODE,
'login_url': auth_utils.login_url,
'jepostule_globally_enabled': settings.JEPOSTULE_QUOTA > 0,
'tag_manager_url': settings.TAG_MANAGER_URL,
}
def test_update_office_social_network(self):
"""
Test `update_offices` to update an office: boost alternance score for specific ROME codes.
"""
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
social_network="https://www.facebook.com/poleemploi/",
)
office_to_update.save()
script.update_offices()
office = Office.get(self.office1.siret)
# Check contact mode
self.assertEqual("https://www.facebook.com/poleemploi/", office.social_network)
def test_update_office_contact_mode(self):
"""
Test `update_offices` to update an office: boost alternance score for specific ROME codes.
"""
office_to_update = OfficeAdminUpdate(
sirets=self.office1.siret,
name=self.office1.company_name,
contact_mode="Come with his driver license",
)
office_to_update.save()
script.update_offices(OfficeAdminUpdate)
office = Office.get(self.office1.siret)
# Check contact mode
self.assertEqual("Come with his driver license", office.contact_mode)
def test_email_alternance_multi_siret(self):
sirets = [self.office1.siret, self.office2.siret]
office_to_update = OfficeAdminUpdate(
sirets='\n'.join(sirets),
name="Supermarché",
email_alternance="*****@*****.**",
phone_alternance="0699999999",
website_alternance="http://example-alternance.com",
)
office_to_update.save(commit=True)
script.update_offices()
for siret in sirets:
office = Office.get(siret)
self.assertEqual(office.email_alternance, "*****@*****.**")
self.assertEqual(office.phone_alternance, "0699999999")
self.assertEqual(office.website_alternance, "http://example-alternance.com")
def inject_dict_for_all_templates():
return {
'hotjar_tag': hotjar.get_hotjar_tag(),
'memo_js_url': settings.MEMO_JS_URL,
'user_is_pro': pro.user_is_pro(),
'pro_version_enabled': pro.pro_version_enabled(),
'last_data_deploy_date': Office.get_date_of_last_data_deploy(),
'google_analytics_id': settings.GOOGLE_ANALYTICS_ID,
'seo_google_analytics_id': settings.SEO_GOOGLE_ANALYTICS_ID,
'enable_google_optimize': settings.ENABLE_GOOGLE_OPTIMIZE,
'google_optimize_id': settings.GOOGLE_OPTIMIZE_ID,
'tilkee_enabled': settings.TILKEE_ENABLED,
'google_site_verification_code':
settings.GOOGLE_SITE_VERIFICATION_CODE,
'login_url': auth_utils.login_url,
'jepostule_globally_enabled': settings.JEPOSTULE_QUOTA > 0,
'enable_isochrones': settings.ENABLE_ISOCHRONES,
}
def test_boost_multi_siret(self):
sirets = [self.office1.siret, self.office2.siret]
office_to_update = OfficeAdminUpdate(
sirets='\n'.join(sirets),
name="Supermarché",
boost=True,
)
office_to_update.save(commit=True)
script.update_offices()
for siret in sirets:
office = Office.get(siret)
res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret)
# Since `romes_to_boost` is empty, all `scores_by_rome` should be boosted.
self.assertEqual(office_to_update.romes_to_boost, "")
for rome in mapping_util.romes_for_naf(office.naf):
self.assertTrue(res['_source']['boosted_romes'][rome.code])
def test_add_offices(self):
"""
Test `add_offices` to add an office.
"""
office_to_add = OfficeAdminAdd(
siret=u"01625043300220",
company_name=u"CHAUSSURES CENDRY",
office_name=u"GEP",
naf=u"4772A",
street_number=u"11",
street_name=u"RUE FABERT",
zipcode=u"57000",
city_code=u"57463",
flag_alternance=0,
flag_junior=0,
flag_senior=0,
departement=u"57",
headcount=u'31',
score=100,
x=6.17528,
y=49.1187,
reason=u"Demande de mise en avant",
)
office_to_add.save()
script.add_offices(index=self.ES_TEST_INDEX)
time.sleep(1) # Sleep required by ES to register new documents.
office = Office.get(office_to_add.siret)
self.assertEquals(office.company_name, office_to_add.company_name)
self.assertEquals(office.score, office_to_add.score)
self.assertEquals(office.email, u"")
self.assertEquals(office.tel, u"")
self.assertEquals(office.website, u"")
res = self.es.get(index=self.ES_TEST_INDEX,
doc_type=self.ES_OFFICE_TYPE,
id=office_to_add.siret)
self.assertEquals(res['_source']['siret'], office.siret)
self.assertEquals(res['_source']['score'], office.score)
def add_offices():
"""
Add offices (complete the data provided by the importer).
"""
for office_to_add in db_session.query(OfficeAdminAdd).all():
office = Office.query.filter_by(siret=office_to_add.siret).first()
# Only create a new office if it does not already exist.
# This guarantees that the importer data will always have precedence.
if not office:
# The `headcount` field of an `OfficeAdminAdd` instance has a `code` attribute.
if hasattr(office_to_add.headcount, 'code'):
headcount = office_to_add.headcount.code
else:
headcount = office_to_add.headcount
# Create the new office in DB.
new_office = Office()
# Use `inspect` because `Office` columns are named distinctly from attributes.
for field_name in list(inspect(Office).columns.keys()):
try:
value = getattr(office_to_add, field_name)
except AttributeError:
# Some fields are not shared between `Office` and `OfficeAdminAdd`.
continue
if field_name == 'headcount':
value = headcount
setattr(new_office, field_name, value)
db_session.add(new_office)
db_session.commit()
# Create the new office in ES.
doc = get_office_as_es_doc(office_to_add)
es.Elasticsearch().create(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office_to_add.siret,
body=doc)
def test_add_offices(self):
"""
Test `add_offices` to add an office.
"""
office_to_add = OfficeAdminAdd(
siret="01625043300220",
company_name="CHAUSSURES CENDRY",
office_name="GEP",
naf="4772A",
street_number="11",
street_name="RUE FABERT",
zipcode="57000",
city_code="57463",
flag_alternance=0,
flag_junior=0,
flag_senior=0,
departement="57",
headcount='31',
score=80,
x=6.17528,
y=49.1187,
reason="Demande de mise en avant",
)
office_to_add.save()
script.add_offices()
office = Office.get(office_to_add.siret)
self.assertEqual(office.company_name, office_to_add.company_name)
self.assertEqual(office.score, office_to_add.score)
self.assertEqual(office.email, "")
self.assertEqual(office.tel, "")
self.assertEqual(office.website, "")
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=office_to_add.siret)
self.assertEqual(res['_source']['siret'], office.siret)
self.assertEqual(res['_source']['score'], office.score)
def setUp(self, *args, **kwargs):
super(ApiBaseTest, self).setUp(*args, **kwargs)
# Insert test data into Elasticsearch.
docs = [
{
'naf':
'7320Z', # Map to ROME D1405.
'siret':
'00000000000001',
'company_name':
'Raison sociale 1',
'score':
68,
'score_alternance':
18,
'headcount':
11,
'locations':
self.positions['bayonville_sur_mad']['coords'],
'name':
'Office 1',
'flag_alternance':
0,
'flag_pmsmp':
0,
'department':
self.positions['bayonville_sur_mad']['zip_code'][0:2],
},
{
'naf':
'7320Z', # Map to ROME D1405.
'siret':
'00000000000002',
'company_name':
'Raison sociale 2',
'score':
69,
'score_alternance':
18,
'headcount':
31,
'locations':
self.positions['bayonville_sur_mad']['coords'],
'name':
'Office 2',
'flag_alternance':
0,
'flag_pmsmp':
0,
'department':
self.positions['bayonville_sur_mad']['zip_code'][0:2],
},
{
'naf':
'7320Z', # Map to ROME D1405.
'siret':
'00000000000003',
'score':
70,
'score_alternance':
18,
'headcount':
31,
'locations':
self.positions['bayonville_sur_mad']['coords'],
'name':
'Office 3',
'flag_alternance':
0,
'flag_pmsmp':
0,
'department':
self.positions['bayonville_sur_mad']['zip_code'][0:2],
},
{
'naf': '7320Z', # Map to ROME D1405.
'siret': '00000000000004',
'score': 71,
'score_alternance': 18,
'headcount': 31,
'locations': self.positions['caen']['coords'],
'name': 'Office 4',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['caen']['zip_code'][0:2],
},
{
'naf': '9511Z', # Map to ROME M1801.
'siret': '00000000000005',
'score': 71,
'score_alternance': 18,
'headcount': 31,
'locations': self.positions['caen']['coords'],
'name': 'Office 5',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['caen']['zip_code'][0:2],
},
# For NAF filter
{
'naf': '4711C', # Map to ROME D1508.
'siret': '00000000000006',
'score': 75,
'score_alternance': 18,
'headcount': 31,
'locations': self.positions['metz']['coords'],
'name': 'Office 6',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['metz']['zip_code'][0:2],
},
{
'naf': '5610C', # Map to ROME D1508.
'siret': '00000000000007',
'score': 70,
'score_alternance': 18,
'headcount': 50,
'locations': self.positions['metz']['coords'],
'name': 'Office 7',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['metz']['zip_code'][0:2],
},
# For result sort
{
'naf': '9103Z', # Map to ROME D1211
'siret': '00000000000008',
'score': 75,
'score_alternance': 51,
'headcount': 50,
'locations': self.positions['nantes']['coords'],
'name': 'Office 8',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['nantes']['zip_code'][0:2],
},
{
'naf': '7010Z', # Map to ROME D1211
'siret': '00000000000009',
'score': 99,
'score_alternance': 51,
'headcount': 50,
'locations':
self.positions['reze']['coords'], # City close to Nantes
'name': 'Office 9',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['reze']['zip_code'][0:2],
},
# For contract filter
{
'naf': '4669A', # Map to Rome D1213
'siret': '00000000000010',
'score': 78,
'score_alternance': 0,
'headcount': 34,
'locations': self.positions['lille']['coords'],
'name': 'Office 10',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['lille']['zip_code'][0:2],
},
{
'naf': '4669A', # Map to Rome D1213
'siret': '00000000000011',
'score': 82,
'score_alternance': 80,
'headcount': 65,
'locations': self.positions['lille']['coords'],
'name': 'Office 11',
'flag_alternance': 1,
'flag_pmsmp': 0,
'department': self.positions['lille']['zip_code'][0:2],
},
# For headcount filter
{
'naf': '7022Z', # Map to Rome M1202
'siret': '00000000000012',
'score': 82,
'score_alternance': 18,
'headcount': 11,
'locations': self.positions['toulouse']['coords'],
'name': 'Office 12',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['toulouse']['zip_code'][0:2],
},
{
'naf': '7010Z', # Map to Rome M1202
'siret': '00000000000013',
'score': 82,
'score_alternance': 18,
'headcount': 22,
'locations': self.positions['toulouse']['coords'],
'name': 'Office 13',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['toulouse']['zip_code'][0:2],
},
# For headcount_text
{
'naf': '4648Z', # Map to Rome B1603
'siret': '00000000000014',
'score': 80,
'score_alternance': 18,
'headcount': 53, # headcount_text : '10 000 salariés et plus'
'locations': self.positions['pau']['coords'],
'name': 'Office 14',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['pau']['zip_code'][0:2],
},
# For flag_alternance in response
{
'naf': '4648Z', # Map to Rome B1603
'siret': '00000000000015',
'score': 80,
'score_alternance': 18,
'headcount': 53,
'locations': self.positions['poitiers']['coords'],
'name': 'Office 15',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['poitiers']['zip_code'][0:2],
},
{
'naf': '4648Z', # Map to Rome B1603
'siret': '00000000000016',
'score': 70,
'score_alternance': 80,
'headcount': 53,
'locations': self.positions['poitiers']['coords'],
'name': 'Office 16',
'flag_alternance': 1,
'flag_pmsmp': 0,
'department': self.positions['poitiers']['zip_code'][0:2],
},
# For filter_by_department and filter_by_flag_pmsmp
{
'naf': '5229A', # Map to Rome N1202
'siret': '00000000000017',
'score': 90,
'score_alternance': 18,
'headcount': 53,
'locations': self.positions['paris']['coords'],
'name': 'Office 17',
'flag_alternance': 0,
'flag_pmsmp': 1,
'department': self.positions['paris']['zip_code'][0:2],
},
{
'naf': '5229A', # Map to Rome N1202
'siret': '00000000000018',
'score': 78,
'score_alternance': 18,
'headcount': 53,
'locations': self.positions['neuilly-sur-seine']['coords'],
'name': 'Office 18',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department':
self.positions['neuilly-sur-seine']['zip_code'][0:2],
},
# For filters in response tests
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000019',
'score': 76,
'score_alternance': 18,
'headcount': 0o1,
'locations': self.positions['toulon']['coords'],
'name': 'Office 19',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['toulon']['zip_code'][0:2],
},
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000020',
'score': 90,
'score_alternance': 18,
'headcount': 0o3,
'locations': self.positions['toulon']['coords'],
'name': 'Office 20',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['toulon']['zip_code'][0:2],
},
{
'naf': '4920Z', # Map to Rome N4403
'siret': '00000000000021',
'score': 43,
'score_alternance': 18,
'headcount': 53,
'locations': self.positions['toulon']['coords'],
'name': 'Office 21',
'flag_alternance': 1,
'flag_pmsmp': 0,
'department': self.positions['toulon']['zip_code'][0:2],
},
# For distance filter => between 10-30km
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000023',
'score': 89,
'score_alternance': 18,
'headcount': 31,
'locations':
self.positions['hyeres']['coords'], # 15km of Toulon
'name': 'Office 23',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['hyeres']['zip_code'][0:2],
},
# For distance filter => between 30-50km
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000024',
'score': 30,
'score_alternance': 18,
'headcount': 12,
'locations':
self.positions['aubagne']['coords'], # 35km of Toulon
'name': 'Office 24',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['aubagne']['zip_code'][0:2],
},
# For distance between 50-100km
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000025',
'score': 82,
'score_alternance': 18,
'headcount': 11,
'locations':
self.positions['draguignan']['coords'], # 60km of Toulon
'name': 'Office 25',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['draguignan']['zip_code'][0:2],
},
# For distance filter => between 100-3000km
{
'naf': '4910Z', # Map to Rome N4403
'siret': '00000000000026',
'score': 67,
'score_alternance': 18,
'headcount': 51,
'locations':
self.positions['limoges']['coords'], # 500km of Toulon
'name': 'Office 26',
'flag_alternance': 0,
'flag_pmsmp': 0,
'department': self.positions['limoges']['zip_code'][0:2],
},
]
for _, doc in enumerate(docs, start=1):
# Build scores for relevant ROME codes.
naf = doc['naf']
rome_codes = list(mapping_util.MANUAL_NAF_ROME_MAPPING[naf].keys())
# FIXME this is some dangerous code duplication with create_index, we should someday
# make it more DNRY.
score = doc['score']
scores_by_rome = {}
for rome_code in rome_codes:
scores_by_rome[
rome_code] = scoring_util.get_score_adjusted_to_rome_code_and_naf_code(
score=score,
rome_code=rome_code,
naf_code=naf,
)
if scores_by_rome:
doc['scores_by_rome'] = scores_by_rome
# FIXME this is some dangerous code duplication with create_index, we should someday
# make it more DNRY.
score_alternance = doc['score_alternance']
scores_alternance_by_rome = {}
for rome_code in rome_codes:
raw_score = scoring_util.get_score_adjusted_to_rome_code_and_naf_code(
score=score_alternance,
rome_code=rome_code,
naf_code=naf,
)
if raw_score > 0: # dirty fix until proper DNRY with create_index
scores_alternance_by_rome[rome_code] = raw_score
if scores_alternance_by_rome:
doc['scores_alternance_by_rome'] = scores_alternance_by_rome
# just like in other environments, id should be the siret
self.es.index(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=doc['siret'],
body=doc)
# need for ES to register our new documents, flaky test here otherwise
self.es.indices.flush(index=settings.ES_INDEX)
# Create related Office instances into MariaDB/MySQL.
for doc in docs:
# Set the right `commune_id` and `zipcode` depending on the location.
commune_id = None
zip_code = None
for position in self.positions:
if doc['locations'] == self.positions[position]['coords']:
commune_id = self.positions[position]['commune_id']
zip_code = self.positions[position]['zip_code']
break
if not commune_id:
raise ValueError(
"Cannot create an entry in Office with a city absent from self.positions."
)
office = Office(
office_name=doc['name'],
siret=doc['siret'],
score=doc['score'],
score_alternance=doc['score_alternance'],
naf=doc['naf'],
city_code=commune_id,
zipcode=zip_code,
email='*****@*****.**',
departement=zip_code[:2],
company_name=doc['company_name']
if 'company_name' in doc else '',
flag_alternance=doc['flag_alternance'],
flag_pmsmp=doc['flag_pmsmp'],
headcount=doc['headcount'],
x=doc['locations'][0]['lon'],
y=doc['locations'][0]['lat'],
)
office.save()
# We should have as much entries in MariaDB/MySQL than in Elasticsearch, except
# one more in ES for the fake document actually.
es_count = self.es.count(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
body={'query': {
'match_all': {}
}})
self.assertEqual(Office.query.count() + 1, es_count['count'])
def setUp(self):
super(CreateIndexBaseTest, self).setUp()
# Mute script logging
script.logger.setLevel(script.logging.CRITICAL)
self.office1 = Office(
siret="78548035101646",
company_name="SUPERMARCHES MATCH",
office_name="SUPERMARCHES MATCH",
naf="4711D",
street_number="45",
street_name="AVENUE ANDRE MALRAUX",
city_code="57463",
zipcode="57000",
email="*****@*****.**",
tel="0387787878",
website="http://www.supermarchesmatch.fr",
flag_alternance=0,
flag_junior=0,
flag_senior=0,
flag_handicap=0,
departement="57",
headcount="12",
score=90,
score_alternance=90,
x=6.17952,
y=49.1044,
)
self.office1.save()
self.office2 = Office(
siret="78548035101647",
company_name="HYPER U",
office_name="HYPER U",
naf="4711D",
street_number="8",
street_name="AVENUE DE LA LIBERATION",
city_code="44101",
zipcode="44620",
email="*****@*****.**",
tel="0240659515",
website="http://www.hyper-u-lamontagne.fr",
flag_alternance=0,
flag_junior=0,
flag_senior=0,
flag_handicap=0,
departement="44",
headcount="21",
score=77,
score_alternance=75,
x=-1.68333,
y=47.183331,
)
self.office2.save()
# We should have 2 offices in the DB.
self.assertEqual(Office.query.count(), 2)
# Put offices into ES.
# Disable parallel computing because it does not play well with test environment (it hangs).
script.create_offices(disable_parallel_computing=True)
self.es.indices.flush(index=settings.ES_INDEX
) # required by ES to register new documents.
# We should have 3 offices in ES (2 + the fake office).
count = self.es.count(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
body={'query': {
'match_all': {}
}})
self.assertEqual(count['count'], 2 + 1)
# Ensure that the office is the one that has been indexed in ES.
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=self.office1.siret)
self.assertEqual(res['_source']['email'], self.office1.email)
res = self.es.get(index=settings.ES_INDEX,
doc_type=es.OFFICE_TYPE,
id=self.office2.siret)
self.assertEqual(res['_source']['email'], self.office2.email)
