def test_too_many_skills(self) -> None:
"""Make sure we do not get too many skills per rome prefix."""
base = airtablemock.Airtable('the-base', 'apikey42')
for i in range(25):
base.create(
'the-table', {
'name': f'Skill {i}',
'description':
'Chercher activement des idées pour aider les gens',
'TIME_TO_MARKET': 55,
'BREADTH_OF_JOBS': 82,
'JOB_SATISFACTION': 58,
'BETTER_INCOME': 33,
'NO_AUTOMATISATION': 36,
'value_score': i + 0.93,
'rome_prefixes': 'J12',
})
skills_per_rome_pefix = dict(
mongo.collection_to_proto_mapping(
skills_for_future.get_skills_per_rome_prefix(
'the-base', 'the-table'), skill_pb2.JobSkills))
self.assertEqual(
['Skill 24', 'Skill 23', 'Skill 22', 'Skill 21', 'Skill 20'],
[skill.name for skill in skills_per_rome_pefix['J12'].skills])
def test_clear(self) -> None:
"""Basic usage of the clear function."""
base1 = airtablemock.Airtable('first-base', '')
base1.create('table', {'number': 8})
airtablemock.clear()
other_client_base1 = airtablemock.Airtable('first-base', '')
other_client_base1.create('table', {'number': 9})
records = base1.iterate('table')
self.assertEqual([9], [
typing.cast(typing.Dict[str, int], record['fields'])['number']
for record in records
])
def test_import(self) -> None:
"""Test importing a CV in mongo."""
base = airtablemock.Airtable('a12345', 'apikey42')
base.create('cvs_and_cover_letters', {
'anonymized_url': [{'url': 'http://mycv.com/PascalCorpet'}],
'name': 'Pascal',
})
document_to_review.main([
'--mongo_url', 'mongodb://localhost/test',
'--base_id', 'a12345',
'--table', 'cvs_and_cover_letters',
])
records = list(base.iterate('cvs_and_cover_letters'))
self.assertEqual(
['Pascal'],
[
typing.cast(Dict[str, Any], r.get('fields', {})).get('name')
for r in records
])
mongo_id = typing.cast(Dict[str, Any], records[0]['fields'])['mongo_id']
self.assertTrue(mongo_id)
database = pymongo.MongoClient()
mongo_records = list(database.test.cvs_and_letters.find())
self.assertEqual(['Pascal'], [r.get('name') for r in mongo_records])
self.assertEqual('http://mycv.com/PascalCorpet', mongo_records[0].get('anonymizedUrl'))
self.assertEqual(mongo_id, str(mongo_records[0].get('_id')))
def test_airtable2dicts_sorted_diagnostic_sentence(self):
"""Use of airtable2dicts when records need to be sorted."""
base = airtablemock.Airtable('base456', 'apikey42')
base.create('diagnostic_template', {
'sentence_template': 'first %inCity',
'order': 1,
})
base.create('diagnostic_template', {
'sentence_template': 'fifth',
'order': 2,
})
base.create('diagnostic_template', {
'sentence_template': 'second',
'order': 1,
})
base.create(
'diagnostic_template', {
'sentence_template': 'fourth',
'filters': ['for-job-group(A12)'],
'order': 2,
'priority': 2,
})
base.create(
'diagnostic_template', {
'sentence_template': 'third',
'filters': ['for-job-group(A12)'],
'order': 2,
'priority': 4,
})
with self.assertRaises(ValueError):
airtable_to_protos.airtable2dicts('base456', 'diagnostic_template',
'DiagnosticSentenceTemplate')
def setUp(self) -> None:
super().setUp()
self._base = airtablemock.Airtable(self._base_name, 'apikey42')
self._table = self.converter_id
airtablemock.create_empty_table(self._base_name, self._table)
translation._TRANSLATION_TABLE = [] # pylint: disable=protected-access
airtablemock.create_empty_table('appkEc8N0Bw4Uok43',
'tblQL7A5EgRJWhQFo')
if self.must_check_translations:
self._translation_base = airtablemock.Airtable(
'appkEc8N0Bw4Uok43', 'apikey42')
else:
patcher = mock.patch(translation.__name__ +
'.fetch_missing_translation_locales')
mock_translate = patcher.start()
mock_translate.return_value = {}
self.addCleanup(patcher.stop)
def setUp(self) -> None:
super().setUp()
airtablemock.create_empty_table('appkEc8N0Bw4Uok43', 'translations')
for base_id, table, view in _TABLES_TO_MOCK:
airtablemock.create_empty_table(base_id, table)
if view:
airtablemock.Airtable(base_id,
'').create_view(table, view,
'unused != 3')
def setUp(self) -> None:
super().setUp()
job_group_info.translation.clear_cache()
client = airtablemock.Airtable('appmy-test-base', 'my-test-api-key')
client.create('soc2fap', {
'O*NET-SOC Code': '11-1011',
'FAP prefixes': ['L6Z', 'L4Z'],
})
client.create(
'skills_for_future', {
'name': 'Jugement et prise de décision',
'description': 'long description',
'soc_prefixes_us': '11-,11-10',
})
airtablemock.Airtable('appkEc8N0Bw4Uok43').create(
'tblQL7A5EgRJWhQFo', {
'string': 'Jugement et prise de décision',
'en': 'Judging & decision making',
})
airtablemock.Airtable('appkEc8N0Bw4Uok43').create(
'tblQL7A5EgRJWhQFo', {
'string': 'long description',
'en': 'long description in English',
})
def test_skip_import(self) -> None:
"""Test not importing a CV in mongo if already present."""
base = airtablemock.Airtable('a12345', 'apikey42')
record_id = typing.cast(str, base.create('cvs_and_cover_letters', {
'anonymized_url': [{'url': 'http://mycv.com/PascalCorpet'}],
'name': 'Pascal',
})['id'])
document_to_review.main([
'--mongo_url', 'mongodb://localhost/test',
'--base_id', 'a12345',
'--table', 'cvs_and_cover_letters',
])
base.update('cvs_and_cover_letters', record_id, {'name': 'Lascap'})
document_to_review.main([
'--mongo_url', 'mongodb://localhost/test',
'--base_id', 'a12345',
'--table', 'cvs_and_cover_letters',
])
records = list(base.iterate('cvs_and_cover_letters'))
fields = typing.cast(Dict[str, Any], records[0]['fields'])
mongo_id = fields['mongo_id']
self.assertTrue(mongo_id)
self.assertTrue(fields.get('Bayes help needed'))
database = pymongo.MongoClient()
mongo_record = database.test.cvs_and_letters.find_one({'_id': objectid.ObjectId(mongo_id)})
assert mongo_record
self.assertEqual('Lascap', mongo_record.get('name'))
self.assertEqual('http://mycv.com/PascalCorpet', mongo_record.get('anonymizedUrl'))
database.test.cvs_and_letters.update_one(
{'_id': objectid.ObjectId(mongo_id)},
{'$set': {'numDoneReviews': 1, 'reviews': [{'status': 'REVIEW_TIME_OUT'}]}},
)
document_to_review.main([
'--mongo_url', 'mongodb://localhost/test',
'--base_id', 'a12345',
'--table', 'cvs_and_cover_letters',
])
record = typing.cast(Dict[str, Any], next(base.iterate('cvs_and_cover_letters'))['fields'])
self.assertFalse(record.get('Bayes help needed'))
self.assertEqual(1, record.get('review_timeouts'))
def test_get_skills_per_rome_prefix(self) -> None:
"""Test the importer for skill for future."""
base = airtablemock.Airtable('the-base', 'apikey42')
base.create(
'the-table', {
'name': 'Orientation client',
'description':
'Chercher activement des idées pour aider les gens',
'TIME_TO_MARKET': 55,
'BREADTH_OF_JOBS': 82,
'JOB_SATISFACTION': 58,
'BETTER_INCOME': 33,
'NO_AUTOMATISATION': 36,
'value_score': 3.93,
'rome_prefixes': 'J12, B11, B15',
})
base.create(
'the-table', {
'name': 'Enseignement',
'description':
"Partager ses compétence et les enseigner à d'autres",
'TIME_TO_MARKET': 70,
'BREADTH_OF_JOBS': 67,
'JOB_SATISFACTION': 79,
'BETTER_INCOME': 54,
'NO_AUTOMATISATION': 21,
'value_score': 5.49,
'rome_prefixes': 'B11, B15, K21',
})
skills_per_rome_pefix = dict(
mongo.collection_to_proto_mapping(
skills_for_future.get_skills_per_rome_prefix(
'the-base', 'the-table'), skill_pb2.JobSkills))
self.assertEqual({'B11', 'B15', 'K21', 'J12'},
skills_per_rome_pefix.keys())
# Point checks
self.assertEqual(
['Enseignement', 'Orientation client'],
[skill.name for skill in skills_per_rome_pefix['B11'].skills])
self.assertEqual([
skill_pb2.JOB_SATISFACTION,
skill_pb2.TIME_TO_MARKET,
], skills_per_rome_pefix['B11'].skills[0].assets)
def test_airtable2dicts(self):
"""Basic usage of airtable2dicts."""
base = airtablemock.Airtable('base123', 'apikey42')
base.create('table456', {
'advice_id': 'my-advice',
'trigger_scoring_model': 'constant(2)',
})
base.create(
'table456', {
'advice_id': 'my-second-advice',
'trigger_scoring_model': 'constant(3)',
})
protos = airtable_to_protos.airtable2dicts('base123', 'table456',
'AdviceModule')
self.assertEqual(['my-advice', 'my-second-advice'],
sorted(m['adviceId'] for m in protos))
def test_csv2dicts(self) -> None:
"""Test basic usage of the csv2dicts function."""
airtable = airtablemock.Airtable('app-mybase')
airtable.create('tbl-my-job-group-info', {
'soc_prefix': '543',
'covidRisk': 'COVID_RISKY',
})
collection = local_diagnosis.csv2dicts(
postings_csv=os.path.join(TESTDATA_FOLDER, 'emsi_postings_counts_2019_area4-occ4.csv'),
occupations_csv=os.path.join(
TESTDATA_FOLDER, 'emsi_occupation_counts_2019_area4-occ4.csv'),
jobs_xls=os.path.join(TESTDATA_FOLDER, 'soc/soc2010.xls'),
career_jumps_csv=os.path.join(TESTDATA_FOLDER, 'soc/career_changers_matrix.csv'),
info_by_prefix_airtable='app-mybase:tbl-my-job-group-info',
salary_filename=os.path.join(
TESTDATA_FOLDER, 'salaries_by_region_2020.xlsx'),
wards_ons_csv=os.path.join(TESTDATA_FOLDER, 'wards.csv'),
geonames_txt=os.path.join(TESTDATA_FOLDER, 'geonames.txt'),
geonames_admin_txt=os.path.join(TESTDATA_FOLDER, 'geonames_admin.txt')
)
protos = dict(mongo.collection_to_proto_mapping(
collection, job_pb2.LocalJobStats))
self.assertEqual(7, len(protos), msg=protos.keys())
# Point checks.
wolverhampton111 = protos['E08000031:1115']
self.assertEqual(2, wolverhampton111.imt.yearly_avg_offers_per_10_candidates)
self.assertEqual('Around £25,424', wolverhampton111.imt.median_salary.short_text)
self.assertEqual(25424, wolverhampton111.imt.median_salary.median_salary)
self.assertEqual(1, wolverhampton111.num_less_stressful_departements)
self.assertEqual(
['2111'], [jg.job_group.rome_id for jg in wolverhampton111.less_stressful_job_groups])
self.assertEqual(
['Chemical scientists'],
[jg.job_group.name for jg in wolverhampton111.less_stressful_job_groups])
# Check empty valued.
self.assertEqual(0, protos['E07000121:1115'].imt.yearly_avg_offers_per_10_candidates)
# Check zero-valued.
self.assertEqual(-1, protos['E07000120:1116'].imt.yearly_avg_offers_per_10_candidates)
# Check saved by the posting durations.
self.assertEqual(4, protos['E07000119:1115'].imt.yearly_avg_offers_per_10_candidates)
def test_airtable2dicts(self):
"""Basic usage of the translations importer."""
base = airtablemock.Airtable('base_t123', 'apikey42')
base.create(
'table456', {
'string': 'String to translate',
'fr': 'La string in French',
'de': 'Die String in German',
})
dicts = list(translations.airtable2dicts('base_t123', 'table456'))
self.assertEqual([{
'string': 'String to translate',
'fr': 'La string in French',
'de': 'Die String in German',
}], dicts)
def test_airtable2dicts(self) -> None:
"""Basic usage of the translations importer."""
base = airtablemock.Airtable('appkEc8N0Bw4Uok43', 'apikey42')
base.create(
'tblQL7A5EgRJWhQFo', {
'string': 'String to translate',
'fr': 'La string in French',
'de': 'Die String in German',
'quick_de': 'Das String aus Deutsch',
})
dicts = list(translations.airtable2dicts())
self.assertEqual([{
'string': 'String to translate',
'fr': 'La string in French',
'de': 'Die String in German',
}], dicts)
def test_airtable2dicts_sorted_diagnostic_submetrics_sentence(self):
"""Use of airtable2dicts when records need to be sorted."""
base = airtablemock.Airtable('base456', 'apikey42')
base.create(
'diagnostic_submetrics_template', {
'positive_sentence_template': 'first',
'submetric': 'JOB_SEARCH_DIAGNOSTIC',
'name': 'foo',
'weight': 1,
'trigger_scoring_model': 'constant(2)',
'negative_sentence_template': ''
})
base.create(
'diagnostic_submetrics_template', {
'positive_sentence_template': 'third',
'submetric': 'MARKET_DIAGNOSTIC',
'name': 'foo',
'weight': 1,
'trigger_scoring_model': 'constant(2)',
'negative_sentence_template': ''
})
base.create(
'diagnostic_submetrics_template', {
'positive_sentence_template': 'second',
'submetric': 'JOB_SEARCH_DIAGNOSTIC',
'name': 'foo',
'weight': 1,
'trigger_scoring_model': 'constant(2)',
'negative_sentence_template': ''
})
with self.assertRaises(ValueError):
airtable_to_protos.airtable2dicts(
'base456', 'diagnostic_submetrics_template',
'DiagnosticSubmetricsSentenceTemplate')
def setUp(self) -> None:
airtablemock.clear()
patcher = mock.patch('airtable.airtable.Airtable', airtablemock.Airtable)
patcher.start()
self.addCleanup(patcher.stop)
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',
})
rome_airtable.create('Rigid Diplomas', {
'code_rome': 'D1501',
'is_diploma_strictly_required': True,
})
rome_airtable.create('info_by_prefix', {
'domain': 'Commerce, vente et grande distribution',
'rome_prefix': 'D',
'inDomain': 'dans le commerce ',
})
rome_airtable.create('info_by_prefix', {
'rome_prefix': 'D15',
'inDomain': 'dans la grande distribution',
'preferredApplicationMedium': 'APPLY_BY_EMAIL',
'hasFreelancers': True,
'inAWorkplace': 'dans un supermarché',
'likeYourWorkplace': 'comme le vôtre',
'placePlural': 'des supermarchés',
'whatILoveAbout': "j'adore vos allées",
'toTheWorkplace': 'A la manufacture',
'whySpecificCompany': 'vous aimez être au service des autres',
'atVariousCompanies': 'à la MAIF, à la MATMUT',
'whatILoveAboutFeminine': "j'adore vos allées",
'covidRisk': 'COVID_RISKY',
})
job_group_info.USERS_MONGO_URL = 'mongodb://fake-mongo-url/test'
db_patcher = mongomock.patch(('fake-mongo-url',))
db_patcher.start()
self.addCleanup(db_patcher.stop)
self.user_db = pymongo.MongoClient('mongodb://fake-mongo-url/test').get_database()
self.user_db.user.insert_many([
{'projects': [{
'isIncomplete': True,
}]},
{
'profile': {'highestDegree': 'CAP_BEP'},
'projects': [{'targetJob': {'jobGroup': {'romeId': 'D1501'}}}],
},
{
'profile': {'highestDegree': 'CAP_BEP'},
'projects': [{'targetJob': {'jobGroup': {'romeId': 'D1501'}}}],
},
{
'profile': {'highestDegree': 'BAC_BACPRO'},
'projects': [{'targetJob': {'jobGroup': {'romeId': 'D1501'}}}],
},
])
def test_make_dicts_full(self) -> None:
"""Test basic usage of the csv2dicts function with all options."""
advice_airtable = airtablemock.Airtable('app01234567', 'key01234567')
advice_airtable.create('jobboards', {
'title': 'CNT',
'link': 'http://www.cnt.asso.fr/metiers_formations/offres_emplois_appels_projets.cfm',
'for-job-group': 'L13',
})
advice_airtable.create('jobboards', {
'title': 'Job Culture',
'link': 'http://www.jobculture.fr/',
'for-job-group': 'L',
})
advice_airtable.create('jobboards', {
'title': 'Indeed',
'link': 'https://www.indeed.com/',
})
advice_airtable.create('skills_for_future', {
'name': 'Jugement et prise de décision',
'description': 'long description',
'rome_prefixes': 'D13, F12, H25, I11, N13, N42, C11, C12, C13, C14, C15, D11, D12, E11',
'soc_prefixes_us': '11-1011, 11-1021, 11-2011, 11-2021',
})
advice_airtable.create('specific_to_job', {
'id': 'baker',
'title': 'Présentez-vous au chef boulanger dès son arrivée tôt le matin',
'expanded_card_items': textwrap.dedent('''\
3 idées pour vous aider à réussir votre approche :
* Se présenter aux boulangers entre 4h et 7h du matin.
* Demander au vendeur / à la vendeuse à quelle heure arrive le chef le matin.
* Contacter les fournisseurs de farine locaux : ils connaissent tous'''),
'card_text': '**Allez à la boulangerie la veille** pour savoir.',
'short_title': 'Astuces de boulangers',
'diagnostic_topics': ['JOB_SEARCH_DIAGNOSTIC'],
'fr:for-job-group': 'D1102',
})
collection = job_group_info.make_dicts(
rome_csv_pattern=self.rome_csv_pattern,
job_requirements_json=self.job_requirements_json,
job_application_complexity_json=self.job_application_complexity_json,
application_mode_csv=self.application_mode_csv,
rome_fap_crosswalk_txt=self.rome_fap_crosswalk_txt,
handcrafted_assets_airtable='app01234567:advice:viw012345',
domains_airtable='app4242:domains',
strict_diplomas_airtable='app4242:Rigid Diplomas',
info_by_prefix_airtable='app4242:info_by_prefix',
fap_growth_2012_2022_csv=self.fap_growth_2012_2022_csv,
imt_market_score_csv=self.imt_market_score_csv,
jobboards_airtable='app01234567:jobboards',
skills_for_future_airtable='app01234567:skills_for_future',
specific_to_job_airtable='app01234567:specific_to_job',
brookings_json=path.join(self.data_folder, 'usa/automation-risk.json'),
soc_2010_xls=path.join(self.data_folder, 'usa/soc/soc_2010_definitions.xls'),
soc_isco_crosswalk_xls=path.join(self.data_folder, 'isco_us_soc2010_crosswalk.xls'),
rome_isco_crosswalk_xlsx=path.join(self.data_folder, 'Correspondance_ROME_ISCO08.xlsx'),
trainings_csv=path.join(self.data_folder, 'cpf_trainings.csv'))
job_group_protos = dict(mongo.collection_to_proto_mapping(collection, job_pb2.JobGroup))
self.assertEqual(
{'CNT', 'Job Culture'},
{j.title for j in job_group_protos['L1301'].job_boards})
self.assertEqual(
{'Job Culture'},
{j.title for j in job_group_protos['L1101'].job_boards})
self.assertFalse(job_group_protos['K1802'].job_boards)
self.assertEqual(
['Jugement et prise de décision'],
[s.name for s in job_group_protos['D1301'].skills_for_future])
self.assertFalse(job_group_protos['K1802'].skills_for_future)
self.assertEqual(
['Astuces de boulangers'],
[s.short_title for s in job_group_protos['D1102'].specific_advice])
self.assertFalse(job_group_protos['K1802'].specific_advice)
# Telemarketers.
# D1408 -> ISCO-08 5244 -> US-SOC 2010 41-9041
self.assertEqual(49, job_group_protos['D1408'].automation_risk)
self.assertEqual(
0, job_group_protos['K1701'].automation_risk, msg='No data for this job group')
# Models.
# L1102 -> ISCO-08 5241 -> US-SOC 2010 41-9012
self.assertEqual(
1, job_group_protos['L1102'].automation_risk, msg='0 risk')
self.assertEqual(1, job_group_protos['A1201'].training_count.very_short_trainings)
culture_counts = job_group_protos['L1301'].training_count
self.assertEqual(0, culture_counts.very_short_trainings)
self.assertEqual(2, culture_counts.short_trainings)
self.assertEqual(0, culture_counts.long_trainings)
self.assertEqual(1, culture_counts.online_trainings)
# Check that values can be json dumped, otherwise the diff will fail.
for value in collection:
json.dumps(value)
def setUp(self) -> None:
super().setUp()
self.client = airtablemock.Airtable('appXmyc7yYj0pOcae', 'key42')
airtablemock.create_empty_table('appXmyc7yYj0pOcae', 'tblJYesuqUHrcISMe')
def setUp(self):
super(ShowUnverifiedDataUsersImporterTestCase, self).setUp()
table = airtablemock.Airtable('app0', 'apikey1')
table.create('table0', {'email': '*****@*****.**'})
table.create('table0', {'email': '*****@*****.**'})
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_make_dicts_full(self) -> None:
"""Test basic usage of the csv2dicts function with all options."""
advice_airtable = airtablemock.Airtable('app01234567', 'key01234567')
advice_airtable.create('jobboards', {
'title': 'CNT',
'link': 'http://www.cnt.asso.fr/metiers_formations/offres_emplois_appels_projets.cfm',
'for-job-group': 'L13',
})
advice_airtable.create('jobboards', {
'title': 'Job Culture',
'link': 'http://www.jobculture.fr/',
'for-job-group': 'L',
})
advice_airtable.create('jobboards', {
'title': 'Indeed',
'link': 'https://www.indeed.com/',
})
advice_airtable.create('skills_for_future', {
'name': 'Jugement et prise de décision',
'description': 'long description',
'rome_prefixes': 'D13, F12, H25, I11, N13, N42, C11, C12, C13, C14, C15, D11, D12, E11',
})
advice_airtable.create('specific_to_job', {
'title': 'Présentez-vous au chef boulanger dès son arrivée tôt le matin',
'expanded_card_items': textwrap.dedent('''\
3 idées pour vous aider à réussir votre approche :
* Se présenter aux boulangers entre 4h et 7h du matin.
* Demander au vendeur / à la vendeuse à quelle heure arrive le chef le matin.
* Contacter les fournisseurs de farine locaux : ils connaissent tous'''),
'card_text': '**Allez à la boulangerie la veille** pour savoir.',
'short_title': 'Astuces de boulangers',
'diagnostic_topics': ['JOB_SEARCH_DIAGNOSTIC'],
'for-job-group': 'D1102',
})
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',
'app4242:Rigid Diplomas',
'app4242:info_by_prefix',
self.fap_growth_2012_2022_csv,
self.imt_market_score_csv,
jobboards_airtable='app01234567:jobboards',
skills_for_future_airtable='app01234567:skills_for_future',
specific_to_job_airtable='app01234567:specific_to_job')
job_group_protos = dict(mongo.collection_to_proto_mapping(collection, job_pb2.JobGroup))
self.assertEqual(
{'CNT', 'Job Culture'},
{j.title for j in job_group_protos['L1301'].job_boards})
self.assertEqual(
{'Job Culture'},
{j.title for j in job_group_protos['L1101'].job_boards})
self.assertFalse(job_group_protos['K1802'].job_boards)
self.assertEqual(
['Jugement et prise de décision'],
[s.name for s in job_group_protos['D1301'].skills_for_future])
self.assertFalse(job_group_protos['K1802'].skills_for_future)
self.assertEqual(
['Astuces de boulangers'],
[s.short_title for s in job_group_protos['D1102'].specific_advice])
self.assertFalse(job_group_protos['K1802'].specific_advice)
def setUp(self) -> None:
super().setUp()
table = airtablemock.Airtable('app0', 'apikey1')
table.create('table0', {'email': '*****@*****.**'})
table.create('table0', {'email': '*****@*****.**'})
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',
})
rome_airtable.create('info_by_prefix', {
'rome_prefix': 'D',
'inDomain': 'dans le commerce ',
})
rome_airtable.create('info_by_prefix', {
'rome_prefix': 'D15',
'inDomain': 'dans la grande distribution',
'preferredApplicationMedium': 'APPLY_BY_EMAIL',
'hasFreelancers': True,
'inAWorkplace': 'dans un supermarché',
'likeYourWorkplace': 'comme le vôtre',
'placePlural': 'des supermarchés',
'whatILoveAbout': "j'adore vos allées",
'toTheWorkplace': 'A la manufacture',
'whySpecificCompany': 'vous aimez être au service des autres',
'atVariousCompanies': 'à la MAIF, à la MATMUT',
'whatILoveAboutFeminine': "j'adore vos allées",
})
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',
'app4242:info_by_prefix',
self.fap_growth_2012_2022_csv)
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.assertAlmostEqual(
30.27,
d1501.application_modes['R2Z83'].modes[0].percentage, places=5)
self.assertEqual('dans la grande distribution', d1501.in_domain)
self.assertEqual(job_pb2.APPLY_BY_EMAIL, d1501.preferred_application_medium)
self.assertTrue(d1501.has_freelancers)
self.assertEqual('dans un supermarché', d1501.in_a_workplace)
self.assertEqual('comme le vôtre', d1501.like_your_workplace)
self.assertEqual('des supermarchés', d1501.place_plural)
self.assertEqual("j'adore vos allées", d1501.what_i_love_about)
self.assertAlmostEqual(.1, d1501.growth_2012_2022, places=5)
self.assertEqual('A la manufacture', d1501.to_the_workplace)
self.assertEqual('vous aimez être au service des autres', d1501.why_specific_company)
self.assertEqual('à la MAIF, à la MATMUT', d1501.at_various_companies)
self.assertEqual("j'adore vos allées", d1501.what_i_love_about_feminine)
# Test default values.
g1204 = job_group_protos['G1204']
self.assertEqual('comme la vôtre', g1204.like_your_workplace)
self.assertEqual('dans une entreprise', g1204.in_a_workplace)
self.assertEqual('des entreprises', g1204.place_plural)
self.assertAlmostEqual(0., g1204.growth_2012_2022, places=5)
self.assertEqual("à l'entreprise", g1204.to_the_workplace)
self.assertEqual('vous vous reconnaissez dans leurs valeurs', g1204.why_specific_company)
# Test null growth.
a1101 = job_group_protos['A1101']
self.assertTrue(a1101.growth_2012_2022)
self.assertAlmostEqual(0., a1101.growth_2012_2022, places=5)
def test_make_dicts(self) -> None:
"""Import of job group info."""
job_group_info.translation.clear_cache()
airtable = airtablemock.Airtable('app2xuIa0KpAWGJBV')
airtable.create('tbl7eVORxOnsCH5mv', {
'soc_prefix': '211',
'covidRisk': 'COVID_SAFE',
})
airtable.create('tbl7eVORxOnsCH5mv', {
'soc_prefix': '1116',
'covidRisk': 'COVID_RISKY',
})
airtable.create('tbl7eVORxOnsCH5mv', {
'soc_prefix': '543',
'covidRisk': 'COVID_RISKY',
})
airtable.create(
'skills_for_future', {
'name': 'Jugement et prise de décision',
'description': 'long description',
'soc_prefixes_uk': '111',
'discover_url': 'https://youtu.be/judging-in-fr',
})
airtablemock.Airtable('appkEc8N0Bw4Uok43').create(
'tblQL7A5EgRJWhQFo', {
'string': 'Jugement et prise de décision',
'en': 'Judging & decision making',
})
airtablemock.Airtable('appkEc8N0Bw4Uok43').create(
'tblQL7A5EgRJWhQFo', {
'string': 'long description',
'en': 'long description in English',
})
airtablemock.Airtable('appkEc8N0Bw4Uok43').create(
'tblQL7A5EgRJWhQFo', {
'string': 'https://youtu.be/judging-in-fr',
'en': 'https://youtu.be/judging-in-en',
})
collection = job_group_info.make_dicts(
postings_csv=path.join(TESTDATA_FOLDER,
'emsi_postings_counts_2019_area4-occ4.csv'),
occupations_csv=path.join(
TESTDATA_FOLDER, 'emsi_occupation_counts_2019_area4-occ4.csv'),
jobs_xls=path.join(TESTDATA_FOLDER, 'soc/soc2010.xls'),
soc2010_js=path.join(TESTDATA_FOLDER, 'soc/socDB.js'),
career_jumps_csv=path.join(TESTDATA_FOLDER,
'soc/career_changers_matrix.csv'),
automation_xls=path.join(TESTDATA_FOLDER,
'automation_probability.xls'),
info_by_prefix_airtable='app2xuIa0KpAWGJBV:tbl7eVORxOnsCH5mv',
occupation_requirements_json=os.path.join(TESTDATA_FOLDER,
'job_requirements.json'),
skills_for_future_airtable='app2xuIa0KpAWGJBV:skills_for_future',
)
self.assertEqual(5, 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))
chief_executives = job_group_protos['1115']
self.assertEqual('Chief executives and senior officials',
chief_executives.name)
self.assertIn('head large enterprises and organisations',
chief_executives.description)
self.assertEqual('Managers, directors and senior officials',
chief_executives.domain)
self.assertEqual(24, chief_executives.automation_risk)
self.assertEqual([4, 2, -1], [
score.local_stats.imt.yearly_avg_offers_per_10_candidates
for score in chief_executives.departement_scores
])
self.assertEqual(['2111'], [
related.job_group.rome_id
for related in chief_executives.related_job_groups
])
chief_related_scientist = chief_executives.related_job_groups[0]
self.assertEqual(1, chief_related_scientist.job_group.automation_risk)
self.assertEqual(job_pb2.CLOSE, chief_related_scientist.mobility_type)
self.assertEqual(1, job_group_protos['2111'].automation_risk)
self.assertEqual(0, job_group_protos['1116'].automation_risk)
self.assertEqual(job_pb2.COVID_RISKY,
job_group_protos['1116'].covid_risk)
self.assertEqual(job_pb2.COVID_SAFE,
job_group_protos['2111'].covid_risk)
self.assertFalse(job_group_protos['1115'].covid_risk)
self.assertEqual(
["Bachelor's degree"],
[ce.name for ce in chief_executives.requirements.diplomas])
self.assertEqual(
['Judging & decision making'],
[s.name for s in job_group_protos['1116'].skills_for_future])
self.assertEqual(
'https://youtu.be/judging-in-en',
job_group_protos['1116'].skills_for_future[0].discover_url)
self.assertFalse(
[s.name for s in job_group_protos['2111'].skills_for_future])
self.assertIn('Vice President',
[job.name for job in chief_executives.samples])
self.assertNotIn('', [job.name for job in chief_executives.samples])
