def test_basic_usage(self):
"""Basic usage."""
requirements = job_offers_requirements.csv2dicts(
path.join(self.testdata_folder, 'job_offers.csv'),
path.join(self.testdata_folder, 'column_names.txt'))
requirements_proto = dict(mongo.collection_to_proto_mapping(
requirements, job_pb2.JobRequirements))
f1106 = requirements_proto['F1106']
self.assertEqual(2, len(f1106.diplomas), f1106.diplomas)
self.assertEqual(
'Bac+2 en Informatique',
f1106.diplomas[1].name)
self.assertEqual(12, f1106.diplomas[1].percent_suggested)
self.assertEqual(1, f1106.diplomas[1].percent_required)
self.assertEqual(
[2],
[e.office_skills_level for e in f1106.office_skills])
self.assertEqual(12, f1106.office_skills[0].percent_suggested)
self.assertEqual(
[job_pb2.CAR],
[l.driving_license for l in f1106.driving_licenses])
self.assertEqual(12, f1106.driving_licenses[0].percent_suggested)
self.assertEqual(100, f1106.driving_licenses[0].percent_required)
self.assertEqual(
[job_pb2.CDD_OVER_3_MONTHS, job_pb2.CDI,
job_pb2.CDD_LESS_EQUAL_3_MONTHS],
[e.contract_type for e in f1106.contract_types])
self.assertEqual(
['10686', '10688', '11753', '16733', '19658'],
[j.code_ogr for j in f1106.specific_jobs])
self.assertEqual(50, f1106.specific_jobs[0].percent_suggested)
def test_fhs2dicts(self):
"""Basic usage of fhs2dicts."""
local_diagnosis = fhs_local_diagnosis.fhs2dicts(
self.durations_csv, self.data_folder)
diagnosed_plan_protos = dict(
mongo.collection_to_proto_mapping(local_diagnosis,
job_pb2.LocalJobStats))
self.assertEqual([
'74002:A1203', 'A1203', 'd74:A1203', 'ghost-r84:A1203', 'r84:A1203'
], sorted(diagnosed_plan_protos.keys()))
proto = diagnosed_plan_protos['74002:A1203']
self.assertEqual(62, proto.unemployment_duration.days)
proto = diagnosed_plan_protos['ghost-r84:A1203']
self.assertEqual(25, proto.unemployment_duration.days)
proto = diagnosed_plan_protos['r84:A1203']
self.assertEqual(25, proto.unemployment_duration.days)
self.assertEqual('ghost-r84', proto.best_city.city_id)
self.assertFalse(proto.best_city.name)
proto = diagnosed_plan_protos['d74:A1203']
self.assertEqual('74002', proto.best_city.city_id)
self.assertEqual('Alby-sur-Chéran', proto.best_city.name)
def test_extract_offers_per_cities(self):
"""Basic usage of extract_offers_per_cities."""
cities = offers_per_city.extract_offers_per_cities(
self.offers_csv,
self.colnames_csv,
'2015-01-01',
data_folder=path.join(path.dirname(__file__), 'testdata'))
city_protos = dict(
mongo.collection_to_proto_mapping(cities,
commute_pb2.HiringCities))
self.assertEqual(['F1106'], list(city_protos.keys()))
f_cities = city_protos['F1106']
self.assertEqual(4, len(f_cities.hiring_cities))
self.assertEqual(10478, f_cities.hiring_cities[1].city.population)
self.assertEqual(2, f_cities.hiring_cities[1].offers)
self.assertEqual(0, f_cities.hiring_cities[2].city.population)
self.assertEqual('Parthenay', f_cities.hiring_cities[1].city.name)
self.assertAlmostEqual(46.65, f_cities.hiring_cities[1].city.latitude)
self.assertAlmostEqual(-0.25, f_cities.hiring_cities[1].city.longitude)
# Test that the arrondissement gets removed for LYON 06
self.assertEqual('Lyon', f_cities.hiring_cities[0].city.name)
def test_get_missions_dict(self, mock_get):
"""Basic usage."""
mock_get().text = (
'''
<jobs>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>69006</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission #2</JobTitle>
<JobId>4200</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/no</applyURL>
<PostalCode>75002</PostalCode>
</job>
</jobs>
''')
missions = dict(
mongo.collection_to_proto_mapping(
volunteering_missions.get_missions_dicts(),
association_pb2.VolunteeringMissions))
self.assertEqual({'69', '75'}, missions.keys())
self.assertEqual(['Cool Mission #2'],
[m.title for m in missions['75'].missions])
def test_get_cities_dicts(self, mock_get):
"""Basic usage."""
mock_get().json.return_value = json.loads('''[
{
"idinsee": "01001",
"nom": "Abergement-Clémenciat",
"url": "\\/territoires\\/auvergne-rhone-alpes\\/ain\\/abergement\\/1001\\/1"
},
{
"idinsee":"32013",
"nom":"Auch",
"url":"\\/territoires\\/occitanie\\/gers\\/auch\\/32013\\/12474"
},
{
"idinsee":"2A004",
"nom":"Ajaccio",
"url":"\\/territoires\\/corse\\/corse-du-sud\\/ajaccio\\/992004\\/37369"
}
]''')
cities = dict(
mongo.collection_to_proto_mapping(eterritoire.get_cities_dicts(),
association_pb2.SimpleLink))
self.assertEqual({'01001', '32013', '2A004'}, cities.keys())
self.assertEqual(
'/territoires/corse/corse-du-sud/ajaccio/992004/37369',
cities['2A004'].path)
def test_basic_usage(self, mock_emploi_store):
"""Basic usage."""
mock_resource = mock_emploi_store.Client().get_package().get_resource()
mock_resource.records.return_value = [
{
'DEPARTEMENT_CODE': '69',
'ROME_PROFESSION_CARD_CODE': 'A1234'
},
{
'DEPARTEMENT_CODE': '69',
'ROME_PROFESSION_CARD_CODE': 'A1234'
},
{
'DEPARTEMENT_CODE': '69',
'ROME_PROFESSION_CARD_CODE': 'A1234'
},
{
'DEPARTEMENT_CODE': '01',
'ROME_PROFESSION_CARD_CODE': 'A1234'
},
]
counts = recent_job_offers_count.download_and_count()
counts_proto = dict(
mongo.collection_to_proto_mapping(counts, job_pb2.LocalJobStats))
self.assertEqual(set(['69:A1234', '01:A1234']), set(counts_proto))
self.assertEqual(3, counts_proto['69:A1234'].num_available_job_offers)
self.assertEqual(1, counts_proto['01:A1234'].num_available_job_offers)
def test_events2dicts(self):
"""Basic usage."""
json.dump([
{
'title': 'Event A',
'organiser': 'Pascal',
'latitude': 45.75,
'longitude': 4.85,
'price': 0,
'id': 'event-a',
'slug': 'slug-event-a',
'date': '2017-08-19',
'category': '["Trouver un job"]',
},
], self.events_file)
self.events_file.close()
collection = workup_events.events2dicts(
self.events_json_path,
io.StringIO(
'''departement_id,max_latitude,max_longitude,min_latitude,min_longitude
38,45.8667,6.18333,44.75,4.76667
69,46.2833,5.1116,45.45,4.3
75,48.86,2.34445,48.86,2.34445
'''))
event_protos = dict(
mongo.collection_to_proto_mapping(collection, event_pb2.Event))
self.assertEqual({'event-a'}, set(event_protos))
event = event_protos['event-a']
self.assertEqual('Event A', event.title)
self.assertEqual('https://www.workuper.com/events/slug-event-a',
event.link)
self.assertEqual(['for-departement(38,69)'], event.filters)
def test_collection_to_proto_mapping_wrong_field(self):
"""Use of unknown proto field in a dict."""
iterator = mongo.collection_to_proto_mapping([
{
'_id': '75056',
'user_id': 'Pascal'
},
], user_pb2.User)
self.assertRaises(mongo.json_format.ParseError, next, iterator)
def test_collection_to_proto_mapping_dupes(self):
"""Use of duplicates in the collection."""
iterator = mongo.collection_to_proto_mapping([
{'_id': '75056', 'userId': 'Pascal'},
{'_id': '75056', 'userId': 'Pascal'},
], user_pb2.User)
next(iterator)
self.assertRaises(KeyError, next, iterator)
def test_collection_to_proto_mapping(self):
"""Basic usage of collection_to_proto_mapping function."""
protos = dict(mongo.collection_to_proto_mapping([
{'_id': '75056', 'userId': 'Pascal'},
{'_id': '69123', 'userId': 'Stephan'},
], user_pb2.User))
self.assertEqual(['69123', '75056'], sorted(protos.keys()))
self.assertEqual('Pascal', protos['75056'].user_id)
self.assertEqual('Stephan', protos['69123'].user_id)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = rome_mobility.csv2dicts(self.rome_csv_pattern)
protos = dict(
mongo.collection_to_proto_mapping(collection,
discovery_pb2.JobsExploration))
# Point checks.
self.assertEqual([
'10976', '10979', '10992', '10994', '11005', '11010', '11036',
'11037', '11044', '11046', '11047', '11052', '11059', '15441',
'F1402', 'G1102', 'G1201', 'G1202'
], sorted(protos))
g1202_proto = protos['G1202']
self.assertEqual(
['G1201', 'G1203', 'G1403', 'K1206', 'K1601', 'K2105', 'K2111'],
sorted(g.job_group.rome_id for g in g1202_proto.job_groups))
g1403 = [
g.job_group for g in g1202_proto.job_groups
if g.job_group.rome_id == 'G1403'
].pop()
self.assertEqual(
"Gestion de structure de loisirs ou d'hébergement touristique",
g1403.name)
samples = [j.code_ogr for j in g1403.samples]
self.assertEqual(3, len(samples))
self.assertEqual(3, len(set(samples)))
self.assertLess(
set(samples),
set([
'14216', '14217', '14234', '14237', '14301', '14322', '14326',
'14356', '14418', '14969', '14970', '14357'
]))
self.assertEqual(3, len(set(j.name for j in g1403.samples)))
# Check exploration suggestion for a job group.
k1601 = [
g.job_group for g in g1202_proto.job_groups
if g.job_group.rome_id == 'K1601'
].pop()
self.assertEqual(['16228', '38584'],
sorted(j.code_ogr for j in k1601.samples))
self.assertEqual([u'Ludothécaire', u'Responsable de ludothèque'],
sorted(j.name for j in k1601.samples))
# Check exploration suggestions for a single job.
_10979_proto = protos['10979']
self.assertEqual(['E1101'],
sorted(g.job_group.rome_id
for g in _10979_proto.job_groups))
self.assertEqual('Animation de site multimédia',
_10979_proto.job_groups[0].job_group.name)
def test_make_dicts(self, mock_airtable):
"""Test basic usage of the csv2dicts function."""
job_group_info.AIRTABLE_API_KEY = 'key01234567'
mock_airtable.Airtable().iterate.return_value = [
{'_id': 'aa', 'fields': {
'code_rome': 'D1501',
'SKILLS': '* Être créatif',
'BONUS SKILLS': "* Avoir le sens de l'humour",
'TRAINING': '* Maîtriser des logiciels',
'other': 'foo',
}},
]
mock_airtable.Airtable.reset_mock()
collection = job_group_info.make_dicts(
self.rome_csv_pattern,
self.job_requirements_json,
self.job_application_complexity_json,
'app01234567:advice:viw012345')
mock_airtable.Airtable.assert_called_once_with('app01234567', 'key01234567')
mock_airtable.Airtable().iterate.assert_called_once_with('advice', view='viw012345')
self.assertEqual(531, len(collection))
for info in collection:
self.assertEqual(info['_id'], info['romeId'])
job_group_protos = dict(mongo.collection_to_proto_mapping(
collection, job_pb2.JobGroup))
# Point check.
d1501 = job_group_protos['D1501']
self.assertEqual('Animateur de vente', d1501.samples[0].masculine_name)
self.assertEqual(1, len(d1501.jobs), d1501.jobs)
self.assertEqual(
'Argumentation commerciale', d1501.requirements.skills[0].name)
self.assertEqual(
['Bac', 'Brevet'],
[d.name for d in d1501.requirements.diplomas])
self.assertEqual(
['Anglais courant'],
[e.name for e in d1501.requirements.extras])
self.assertEqual('* Être créatif', d1501.requirements.skills_short_text)
self.assertEqual("* Avoir le sens de l'humour", d1501.requirements.bonus_skills_short_text)
self.assertEqual('* Maîtriser des logiciels', d1501.requirements.trainings_short_text)
self.assertEqual('E', d1501.holland_code_major)
self.assertEqual('R', d1501.holland_code_minor)
self.assertTrue(d1501.description.startswith(
'Effectue la promotion et la vente de vêtements'))
self.assertTrue(d1501.working_environment.startswith(
"L'activité de cet emploi/métier s'exerce au sein de grandes"))
self.assertIn('Le permis B peut être requis', d1501.requirements_text)
self.assertEqual(
['Boutique, commerce de détail'],
d1501.work_environment_keywords.structures)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = city_locations.csv2dicts(self.stats_filename)
protos = dict(mongo.collection_to_proto_mapping(collection, geo_pb2.FrenchCity))
self.assertEqual(11, len(protos))
# Point check.
city = protos['39001']
self.assertAlmostEqual(47.0667, city.latitude)
self.assertAlmostEqual(5.38333, city.longitude)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = unverified_data_zones.csv2dicts(self.testdata_folder)
protos = dict(
mongo.collection_to_proto_mapping(collection,
user_pb2.UnverifiedDataZone))
self.assertEqual(533, len(protos))
# Point check.
key = hashlib.md5('03120:A1301'.encode('utf-8')).hexdigest()
unverified_zone_entry = protos[key]
self.assertEqual('03120', unverified_zone_entry.postcodes)
self.assertEqual('A1301', unverified_zone_entry.rome_id)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = job_offers.csv2dicts(self.job_offers_csv,
self.colnames_csv)
self.assertEqual(4, len(collection))
collection_proto = dict(
mongo.collection_to_proto_mapping(
collection, job_offer_counts_pb2.JobOfferCounts))
# Point check, csv designed to match these numbers.
city_id = '79202'
city = collection_proto['F1106:c' + city_id]
self.assertEqual(city_id, city.city.city_id)
self.assertEqual(2, city.city_count)
self.assertEqual(6, city.departement_count)
self.assertEqual(7, city.region_count)
def test_basic_usage(self):
"""Basic usage."""
changes = job_offers_changes.csv2dicts(
path.join(self.testdata_folder, 'job_offers.csv'),
path.join(self.testdata_folder, 'column_names.txt'))
changes_proto = dict(
mongo.collection_to_proto_mapping(changes, job_pb2.LocalJobStats))
self.assertEqual(set(['78:F1106', '79:F1106']), set(changes_proto))
proto = changes_proto['79:F1106']
self.assertEqual(500, proto.job_offers_change)
self.assertEqual(6, proto.num_job_offers_last_year)
self.assertEqual({2014: 1, 2015: 6}, proto.num_job_offers_per_year)
proto = changes_proto['78:F1106']
self.assertEqual({2015: 1}, proto.num_job_offers_per_year)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = local_diagnosis.csv2dicts(
self.bmo_csv, self.fap_rome, self.salaries_csv,
self.unemployment_duration_csv, self.job_offers_changes_json,
self.job_imt_json, self.mobility_csv, self.data_folder)
self.assertEqual(17, len(collection))
protos = dict(mongo.collection_to_proto_mapping(
collection, job_pb2.LocalJobStats))
# Point checks.
a1301 = protos['971:A1301']
self.assertEqual(54, a1301.bmo.percent_difficult)
self.assertEqual(0, a1301.bmo.percent_seasonal)
self.assertEqual(-15, a1301.job_offers_change)
proto = protos['36:A1203']
self.assertEqual(17935, proto.salary.min_salary)
self.assertEqual(17965, proto.salary.max_salary)
self.assertEqual(0, proto.job_offers_change)
proto = protos['74:A1203']
self.assertEqual(17800, proto.salary.max_salary)
self.assertEqual(17700, proto.salary.min_salary)
self.assertEqual('17 700 - 17 800', proto.salary.short_text)
self.assertEqual(job_pb2.ANNUAL_GROSS_SALARY, proto.salary.unit)
proto = protos['971:A1203']
self.assertEqual(25, proto.unemployment_duration.days)
proto = protos['09:F1402']
self.assertEqual(2750, proto.imt.junior_salary.max_salary)
proto = protos['10:F1402']
self.assertEqual(1, len(proto.less_stressful_job_groups))
less_stressful = proto.less_stressful_job_groups[0]
self.assertEqual('F1702', less_stressful.job_group.rome_id)
self.assertEqual(6, less_stressful.local_stats.imt.yearly_avg_offers_per_10_candidates)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
offers = seasonal_jobbing.csv2dicts(self.offers_csv)
offers_proto = dict(
mongo.collection_to_proto_mapping(
offers, seasonal_jobbing_pb2.MonthlySeasonalJobbingStats))
self.assertEqual([3], list(offers_proto.keys()))
march_proto = offers_proto[3]
self.assertEqual(
['06'], [d.departement_id for d in march_proto.departement_stats])
first_departement_proto = march_proto.departement_stats[0]
self.assertEqual('06', first_departement_proto.departement_id)
self.assertEqual(793,
first_departement_proto.departement_seasonal_offers)
self.assertEqual(11, len(first_departement_proto.job_groups))
self.assertEqual('Personnel de cuisine',
first_departement_proto.job_groups[0].name.strip())
self.assertEqual(166, first_departement_proto.job_groups[0].offers)
self.assertEqual('G1602',
first_departement_proto.job_groups[0].rome_id)
def test_country_wide(self, mock_get):
"""Mission available countrywide."""
mock_get().text = (
'''
<jobs>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>13001</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>31000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>33000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>35000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>59000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>69001</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>06000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>34000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>44000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>67000</PostalCode>
</job>
<job>
<JobTitle>Bénévolat : Cool Mission</JobTitle>
<JobId>12345</JobId>
<JobDescription>Mission proposée par Bayes Impact<br />'''
'''<b>Informations complémentaires</b>Nothing</JobDescription>
<applyURL>https://www.example.com/yes</applyURL>
<PostalCode>75001</PostalCode>
</job>
</jobs>
''')
missions = dict(
mongo.collection_to_proto_mapping(
volunteering_missions.get_missions_dicts(),
association_pb2.VolunteeringMissions))
self.assertEqual({''}, missions.keys())
self.assertEqual(['Cool Mission'],
[m.title for m in missions[''].missions])
def test_make_dicts(self):
"""Test basic usage of the csv2dicts function."""
job_group_info.AIRTABLE_API_KEY = 'key01234567'
advice_airtable = airtablemock.Airtable('app01234567', 'key01234567')
advice_airtable.create(
'advice', {
'code_rome': 'D1501',
'SKILLS': '* Être créatif',
'BONUS SKILLS': "* Avoir le sens de l'humour",
'TRAINING': '* Maîtriser des logiciels',
'other': 'foo',
})
rome_airtable = airtablemock.Airtable('app4242', 'key01234567')
rome_airtable.create(
'domains', {
'name': 'Commerce de gros',
'domain_name': 'Commerce, négoce et distribution',
})
rome_airtable.create(
'domains', {
'name': 'Commerce/grande distribution',
'domain_name': 'Commerce, négoce et distribution',
})
collection = job_group_info.make_dicts(
self.rome_csv_pattern, self.job_requirements_json,
self.job_application_complexity_json, self.application_mode_csv,
self.rome_fap_crosswalk_txt, 'app01234567:advice:viw012345',
'app4242:domains')
self.assertEqual(532, len(collection))
for info in collection:
self.assertEqual(info['_id'], info['romeId'])
job_group_protos = dict(
mongo.collection_to_proto_mapping(collection, job_pb2.JobGroup))
# Point check.
d1501 = job_group_protos['D1501']
self.assertEqual('Animateur de vente', d1501.samples[0].masculine_name)
self.assertEqual(1, len(d1501.jobs), d1501.jobs)
self.assertEqual('Argumentation commerciale',
d1501.requirements.skills[0].name)
self.assertEqual(['Bac', 'Brevet'],
[d.name for d in d1501.requirements.diplomas])
self.assertEqual(['Anglais courant'],
[e.name for e in d1501.requirements.extras])
self.assertEqual('* Être créatif',
d1501.requirements.skills_short_text)
self.assertEqual("* Avoir le sens de l'humour",
d1501.requirements.bonus_skills_short_text)
self.assertEqual('* Maîtriser des logiciels',
d1501.requirements.trainings_short_text)
self.assertEqual('E', d1501.holland_code_major)
self.assertEqual('R', d1501.holland_code_minor)
self.assertTrue(
d1501.description.startswith(
'Effectue la promotion et la vente de vêtements'))
self.assertTrue(
d1501.working_environment.startswith(
"L'activité de cet emploi/métier s'exerce au sein de grandes"))
self.assertIn('Le permis B peut être requis', d1501.requirements_text)
self.assertEqual(['Boutique, commerce de détail'],
d1501.work_environment_keywords.structures)
self.assertEqual(
['Commerce, négoce et distribution'],
[d.name for d in d1501.work_environment_keywords.domains])
self.assertEqual(
['Commerce de gros', 'Commerce/grande distribution'],
sorted(d1501.work_environment_keywords.domains[0].sectors))
self.assertEqual(job_pb2.SPONTANEOUS_APPLICATION,
d1501.application_modes['R2Z83'].modes[0].mode)
self.assertEqual(30.27,
d1501.application_modes['R2Z83'].modes[0].percentage)
def test_csv2dicts(self):
"""Test basic usage of the csv2dicts function."""
collection = local_diagnosis.csv2dicts(
self.bmo_csv, self.fap_rome, self.pcs_rome, self.salaries_csv,
self.unemployment_duration_csv, self.job_offers_changes_json,
self.job_imt_json, self.market_score_csv, self.mobility_csv,
self.employment_type_csv, self.imt_salaries_csv, self.data_folder)
self.assertEqual(17, len(collection))
protos = dict(
mongo.collection_to_proto_mapping(collection,
job_pb2.LocalJobStats))
# Point checks.
a1301 = protos['971:A1301']
self.assertEqual(54, a1301.bmo.percent_difficult)
self.assertEqual(0, a1301.bmo.percent_seasonal)
self.assertEqual(-15, a1301.job_offers_change)
proto = protos['36:A1203']
self.assertEqual(17935, proto.salary.min_salary)
self.assertEqual(17965, proto.salary.max_salary)
self.assertEqual(0, proto.job_offers_change)
proto = protos['74:A1203']
self.assertEqual(17800, proto.salary.max_salary)
self.assertEqual(17700, proto.salary.min_salary)
self.assertEqual('17 700 - 17 800', proto.salary.short_text)
self.assertEqual(job_pb2.ANNUAL_GROSS_SALARY, proto.salary.unit)
proto = protos['971:A1203']
self.assertEqual(25, proto.unemployment_duration.days)
proto = protos['09:F1402']
self.assertEqual(2900, proto.imt.junior_salary.max_salary)
self.assertEqual(1550, proto.imt.junior_salary.min_salary)
self.assertEqual('De 1550€ à 2900€',
proto.imt.junior_salary.short_text)
employment_type_percentages = [
employment_type.percentage
for employment_type in proto.imt.employment_type_percentages
]
employment_type_codes = [
employment_type.employment_type
for employment_type in proto.imt.employment_type_percentages
]
self.assertCountEqual([51., 49.0], employment_type_percentages)
self.assertCountEqual([3, 4], employment_type_codes)
proto = protos['10:F1402']
self.assertEqual(1, len(proto.less_stressful_job_groups))
less_stressful = proto.less_stressful_job_groups[0]
self.assertEqual('F1702', less_stressful.job_group.rome_id)
self.assertEqual(
6,
less_stressful.local_stats.imt.yearly_avg_offers_per_10_candidates)
proto = protos['09:F1702']
self.assertEqual(24, proto.imt.last_week_demand)
self.assertEqual(2, proto.imt.last_week_offers)
self.assertEqual(True, proto.imt.seasonal)
self.assertCountEqual([job_pb2.OCTOBER], proto.imt.active_months)
proto = protos['12:F1402']
self.assertFalse(proto.imt.active_months)
