def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone", "Almenno"
],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI", "AL"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"],
"veicolo__a___sesso_conducente": [1, 1, 2, 0, 1, 1, 0],
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio","Roncolate", "Vimodrone"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI"],
"COL01": [ 0, 1, 1, 1, 1, 4], # Incolume: 4, Morto: 1
"COL02": [ 4, 3, 1, 2, 2, 1], # Incolume: 2, Morto: 2, Ferito: 2
"COL03": [ 1, 1, 2, 2, 4, 1], # Incolume: 3, Morto: 1, Ferito: 2
"ODEA01": [ 0, 0, 2, 1, 0, 1], # 4
"OINJ01": [ 3, 0, 0, 0, 5, 0], # 8
"OINJ02": [ 6, 0, 1, 1, 0, 1], # 9
"natura_incidente":[11, 1, 1, 2, 2, 1]
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
class TestIncidentsDataframeAggregator(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_number_of_incidents_by_comune
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], "convert_to_number": []}}'
config = json.loads(s_config)
incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = SupportDecodeDataframes(),
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate"],
"comune": ["1001", "1000", "1000", "1002", "1003" ],
"provincia": ["MI", "CO", "CO", "MI", "BG"],
"tipo_veicolo_a": [ 1, 1, 2, 1, 2]
}
incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(incidenti)
def test_get_number_of_incidents_by_comune(self):
"""
:return:
"""
try:
expected_result = 2
result = self.aggregator.get_number_of_incidents_by_comune("Como")
self.assertTrue(result == expected_result, "Check result - multiple rows returned.")
expected_result = 1
result = self.aggregator.get_number_of_incidents_by_comune("Roncolate")
self.assertTrue(result == expected_result, "Check result - single row returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_number_of_incidents_by_not_existing_comune(self):
"""
:return:
"""
result = 0
expected_result = 0
try:
result = self.aggregator.get_number_of_incidents_by_comune("Pero")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
self.assertTrue(result == expected_result)
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], "convert_to_number": []}}'
config = json.loads(s_config)
incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = SupportDecodeDataframes(),
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate"],
"comune": ["1001", "1000", "1000", "1002", "1003" ],
"provincia": ["MI", "CO", "CO", "MI", "BG"],
"tipo_veicolo_a": [ 1, 1, 2, 1, 2]
}
incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(incidenti)
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone", "Peschiera Borromeo"
],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI", "MI"],
"veicolo__a___esito_conducente": [1, 1, 3, 0, 1, 0, 0],
"veicolo__a___passeggeri_an35": [1, 2, 1, 0, 1, 0, 0],
"veicolo__a___esito_passegg38": [2, 1, 0, 0, 3, 0, 0],
"veicolo__a___esito_passegg41": [2, 1, 2, 0, 4, 0, 0],
"veicolo__a___esito_passegg44": [3, 3, 4, 0, 0, 0, 0]
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
self.outcome_labels = [
"Incolume", "Ferito", "Morto nelle 24 ore",
"Morto entro il trentesimo giorno", "Non dato"
]
def main(args):
log = logging.getLogger('RunIncidenti')
log.info("************> INIZIO <************")
rv = False
try:
if os.path.isfile(args.config_file) == False:
log.error("Invalid config file parameter: {fi}".format(
fi=args.config_file))
return rv
with open(args.config_file) as fconfig:
config = json.load(fconfig)
base_dir = config['data_files']['data_path']
incidenti_fn = config['data_files']['file_incidenti']
com_anagr_fn = config['data_files']['anagrafica_comuni']
anagrafica_comuni = AnagraficaComuni(
file_comuni_anagrafica=os.path.join(base_dir, com_anagr_fn))
support_dataframes = SupportDecodeDataframes()
incidenti = Incidenti(
file_incidenti=os.path.join(base_dir, incidenti_fn),
anagrafica_comuni=anagrafica_comuni,
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
rv = incidenti.load_data_files()
aggregator = IncidentsDataframeAggregator(incidenti)
if rv == False:
log.error("Fallita lettura dei datafile.")
else:
if args.operation == "article":
rv = article_artifacts_maker(aggregator, incidenti, config)
elif args.operation == "debug":
aggregator.get_incidents_outcome_by_typology('nation_wide')
aggregator.calculate_total_incident_outcome()
chart_male_female(aggregator, config)
chart_incident_typology(aggregator, config)
chart_hourly_incidents(aggregator, config)
passengers_outcome("province", "Milano", aggregator,
incidenti, config)
except Exception as ex:
log.error("The job returned an error - {ex}".format(ex=str(ex)))
if rv == False:
log.error("Operation failed - calculated data is not valid.")
log.info("************> FINE <************")
return rv
class TestIncidentsDataframeAggregator_get_veicle_passengers_outcome(TestCase):
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone", "Peschiera Borromeo"
],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI", "MI"],
"veicolo__a___esito_conducente": [1, 1, 3, 0, 1, 0, 0],
"veicolo__a___passeggeri_an35": [1, 2, 1, 0, 1, 0, 0],
"veicolo__a___esito_passegg38": [2, 1, 0, 0, 3, 0, 0],
"veicolo__a___esito_passegg41": [2, 1, 2, 0, 4, 0, 0],
"veicolo__a___esito_passegg44": [3, 3, 4, 0, 0, 0, 0]
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
self.outcome_labels = [
"Incolume", "Ferito", "Morto nelle 24 ore",
"Morto entro il trentesimo giorno", "Non dato"
]
def test_get_passengers_outcome_unknown_area(self):
try:
result = self.aggregator.get_veicle_passengers_outcome(
area="UNKNOWN", city=None)
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_city_none(self):
try:
result = self.aggregator.get_veicle_passengers_outcome(area="city",
city=None)
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_veicle_passengers_outcome_city(self):
try:
conducente_expected = pd.Series([1, 0, 1, 0, 0],
index=self.outcome_labels)
conducente_expected.sort_index(inplace=True)
pass_ant_expected = pd.Series([1, 1, 0, 0, 0],
index=self.outcome_labels)
pass_ant_expected.sort_index(inplace=True)
pass_pos_1_expected = pd.Series([1, 0, 0, 0, 1],
index=self.outcome_labels)
pass_pos_1_expected.sort_index(inplace=True)
pass_pos_2_expected = pd.Series([1, 1, 0, 0, 0],
index=self.outcome_labels)
pass_pos_2_expected.sort_index(inplace=True)
pass_pos_3_expected = pd.Series([0, 0, 1, 1, 0],
index=self.outcome_labels)
pass_pos_3_expected.sort_index(inplace=True)
df_result = self.aggregator.get_veicle_passengers_outcome(
"city", "Como")
self.assertTrue(df_result is not None,
"A valid result must be returned.")
conducente_df = df_result.loc["Conducente"]
conducente_df.sort_index(inplace=True)
self.assertTrue(conducente_df.equals(conducente_expected),
"Check conducente.")
pass_ant_df = df_result.loc["Passeggero anteriore"]
pass_ant_df.sort_index(inplace=True)
self.assertTrue(pass_ant_df.equals(pass_ant_expected),
"Check passeggero anteriore.")
pass_pos_1_df = df_result.loc["Passeggero posteriore 1"]
pass_pos_1_df.sort_index(inplace=True)
self.assertTrue(pass_pos_1_df.equals(pass_pos_1_expected),
"Check passeggero posteriore 1.")
pass_pos_2_df = df_result.loc["Passeggero posteriore 2"]
pass_pos_2_df.sort_index(inplace=True)
self.assertTrue(pass_pos_2_df.equals(pass_pos_2_expected),
"Check passeggero posteriore 2.")
pass_pos_3_df = df_result.loc["Passeggero posteriore 3"]
pass_pos_3_df.sort_index(inplace=True)
self.assertTrue(pass_pos_3_df.equals(pass_pos_3_expected),
"Check passeggero posteriore 3.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_veicle_passengers_outcome_province(self):
try:
conducente_expected = pd.Series([1, 0, 0, 0, 0],
index=self.outcome_labels)
conducente_expected.sort_index(inplace=True)
pass_ant_expected = pd.Series([1, 0, 0, 0, 0],
index=self.outcome_labels)
pass_ant_expected.sort_index(inplace=True)
pass_pos_1_expected = pd.Series([0, 0, 1, 0, 0],
index=self.outcome_labels)
pass_pos_1_expected.sort_index(inplace=True)
pass_pos_2_expected = pd.Series([0, 0, 0, 1, 0],
index=self.outcome_labels)
pass_pos_2_expected.sort_index(inplace=True)
pass_pos_3_expected = pd.Series([0, 0, 0, 0, 1],
index=self.outcome_labels)
pass_pos_3_expected.sort_index(inplace=True)
df_result = self.aggregator.get_veicle_passengers_outcome(
"province", "BG")
self.assertTrue(df_result is not None,
"A valid result must be returned.")
conducente_df = df_result.loc["Conducente"]
conducente_df.sort_index(inplace=True)
self.assertTrue(conducente_df.equals(conducente_expected),
"Check conducente.")
pass_ant_df = df_result.loc["Passeggero anteriore"]
pass_ant_df.sort_index(inplace=True)
self.assertTrue(pass_ant_df.equals(pass_ant_expected),
"Check passeggero anteriore.")
pass_pos_1_df = df_result.loc["Passeggero posteriore 1"]
pass_pos_1_df.sort_index(inplace=True)
self.assertTrue(pass_pos_1_df.equals(pass_pos_1_expected),
"Check passeggero posteriore 1.")
pass_pos_2_df = df_result.loc["Passeggero posteriore 2"]
pass_pos_2_df.sort_index(inplace=True)
self.assertTrue(pass_pos_2_df.equals(pass_pos_2_expected),
"Check passeggero posteriore 2.")
pass_pos_3_df = df_result.loc["Passeggero posteriore 3"]
pass_pos_3_df.sort_index(inplace=True)
self.assertTrue(pass_pos_3_df.equals(pass_pos_3_expected),
"Check passeggero posteriore 3.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_veicle_passengers_outcome_nation_wide(self):
try:
conducente_expected = pd.Series([3, 0, 1, 0, 3],
index=self.outcome_labels)
conducente_expected.sort_index(inplace=True)
pass_ant_expected = pd.Series([3, 1, 0, 0, 3],
index=self.outcome_labels)
pass_ant_expected.sort_index(inplace=True)
pass_pos_1_expected = pd.Series([1, 1, 1, 0, 4],
index=self.outcome_labels)
pass_pos_1_expected.sort_index(inplace=True)
pass_pos_2_expected = pd.Series([1, 2, 0, 1, 3],
index=self.outcome_labels)
pass_pos_2_expected.sort_index(inplace=True)
pass_pos_3_expected = pd.Series([0, 0, 2, 1, 4],
index=self.outcome_labels)
pass_pos_3_expected.sort_index(inplace=True)
df_result = self.aggregator.get_veicle_passengers_outcome(
"nation_wide", city=None)
self.assertTrue(df_result is not None,
"A valid result must be returned.")
conducente_df = df_result.loc["Conducente"]
conducente_df.sort_index(inplace=True)
self.assertTrue(conducente_df.equals(conducente_expected),
"Check conducente.")
pass_ant_df = df_result.loc["Passeggero anteriore"]
pass_ant_df.sort_index(inplace=True)
self.assertTrue(pass_ant_df.equals(pass_ant_expected),
"Check passeggero anteriore.")
pass_pos_1_df = df_result.loc["Passeggero posteriore 1"]
pass_pos_1_df.sort_index(inplace=True)
self.assertTrue(pass_pos_1_df.equals(pass_pos_1_expected),
"Check passeggero posteriore 1.")
pass_pos_2_df = df_result.loc["Passeggero posteriore 2"]
pass_pos_2_df.sort_index(inplace=True)
self.assertTrue(pass_pos_2_df.equals(pass_pos_2_expected),
"Check passeggero posteriore 2.")
pass_pos_3_df = df_result.loc["Passeggero posteriore 3"]
pass_pos_3_df.sort_index(inplace=True)
self.assertTrue(pass_pos_3_df.equals(pass_pos_3_expected),
"Check passeggero posteriore 3.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator_get_male_female_by_area(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_male_female_by_area
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone", "Almenno"
],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI", "AL"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"],
"veicolo__a___sesso_conducente": [1, 1, 2, 0, 1, 1, 0],
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_get_male_female_by_area_nation_wide(self):
try:
expected_male = 4
expected_female = 1
expected_unknown = 2
result = self.aggregator.get_male_female_by_area("nation_wide")
self.assertTrue(result is not None, "None return not allowed.")
result.set_index('Sesso conducente', inplace=True)
result_male = result.loc['maschio', 'Numero']
self.assertTrue(result_male == expected_male,
"Check numeric result - male.")
result_female = result.loc['femmina', 'Numero']
self.assertTrue(result_female == expected_female,
"Check numeric result - female.")
result_unknown = result.loc['non dato', 'Numero']
self.assertTrue(result_unknown == expected_unknown,
"Check numeric result - unknown.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_male_female_by_area_province(self):
try:
expected_male = 2
expected_unknown = 1
result = self.aggregator.get_male_female_by_area("province", "MI")
self.assertTrue(result is not None, "None return not allowed.")
result.set_index('Sesso conducente', inplace=True)
result_male = result.loc['maschio', 'Numero']
self.assertTrue(result_male == expected_male,
"Check numeric result - male.")
self.assertFalse('femmina' in result.index,
"Check numeric result - female.")
result_unknown = result.loc['non dato', 'Numero']
self.assertTrue(result_unknown == expected_unknown,
"Check numeric result - unknown.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_male_female_by_area_city(self):
try:
expected_male = 1
expected_female = 1
result = self.aggregator.get_male_female_by_area("city", "Como")
self.assertTrue(result is not None, "None return not allowed.")
result.set_index('Sesso conducente', inplace=True)
result_male = result.loc['maschio', 'Numero']
self.assertTrue(result_male == expected_male,
"Check numeric result - male.")
result_female = result.loc['femmina', 'Numero']
self.assertTrue(result_female == expected_female,
"Check numeric result - female.")
self.assertFalse('non dato' in result.index,
"Check numeric result - unknown.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_male_female_by_area_unknown_area(self):
try:
result = self.aggregator.get_male_female_by_area(
"province", "NOT KNOWN")
self.assertTrue(result is None, "No result returned - province.")
result = self.aggregator.get_male_female_by_area(
"city", "NOT KNOWN")
self.assertTrue(result is None, "No result returned - city.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator_get_number_of_incidents_by_hour(
TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_number_of_incidents_by_hour
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone"
],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI"],
"COL01": [0, 1, 1, 1, 1, 4], # Incolume: 4, Morto: 1
"COL02": [4, 3, 1, 2, 2, 1], # Incolume: 2, Morto: 2, Ferito: 2
"COL03": [1, 1, 2, 2, 4, 1], # Incolume: 3, Morto: 1, Ferito: 2
"ODEA01": [0, 0, 2, 1, 0, 1], # 4
"OINJ01": [3, 0, 0, 0, 5, 0], # 8
"OINJ02": [6, 0, 1, 1, 0, 1], # 9
"natura_incidente": [11, 1, 1, 2, 2, 1],
"Ora": [15, 2, 10, 2, 2, 11],
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_get_number_of_incidents_by_hour_unknown_area(self):
try:
result = self.aggregator.get_number_of_incidents_by_hour("UNKNOWN")
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_number_of_incidents_by_hour_nation_wide_area(self):
try:
expected_results = {15: 1, 10: 1, 11: 1, 2: 3}
result_df = self.aggregator.get_number_of_incidents_by_hour(
"nation_wide")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results),
"Check the number of found results.")
for key in expected_results.keys():
rs = result_df.loc[key]['Numero']
self.assertTrue(rs == expected_results[key],
"Check result for hour {hh}".format(hh=key))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_number_of_incidents_by_hour_province_area(self):
try:
expected_results = {15: 1, 11: 1, 2: 1}
result_df = self.aggregator.get_number_of_incidents_by_hour(
"province", "MI")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results),
"Check the number of found results.")
for key in expected_results.keys():
rs = result_df.loc[key]['Numero']
self.assertTrue(rs == expected_results[key],
"Check result for hour {hh}".format(hh=key))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_number_of_incidents_by_hour_city_area(self):
try:
expected_results = {2: 1, 10: 1}
result_df = self.aggregator.get_number_of_incidents_by_hour(
"city", "Como")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results),
"Check the number of found results.")
for key in expected_results.keys():
rs = result_df.loc[key]['Numero']
self.assertTrue(rs == expected_results[key],
"Check result for hour {hh}".format(hh=key))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->__calculate_incident_outcome
NOTE: this is a private method so this test could be removed.
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], "convert_to_number": [],"incident_outcome_columns":["COL01","COL02","COL03"]}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio","Roncolate"],
"comune": ["1001", "1000", "1000", "1002", "1003"],
"Provincia": ["MI", "CO", "CO", "MI", "BG"],
"COL01": [ 0, 1, 1, 1, 1],
"COL02": [ 4, 3, 1, 2, 2],
"COL03": [ 1, 1, 2, 2, 4]
}
incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(incidenti)
def test___calculate_incident_outcome(self):
try:
expected_incolumi = 7
expected_feriti = 4
expected_morti = 3
result_df = self.aggregator._IncidentsDataframeAggregator__calculate_incident_outcome()
self.assertTrue(result_df, "Must return the ok result.")
df = self.aggregator._IncidentsDataframeAggregator__df()
n_incolumi = df['Incolumi'].sum()
n_feriti = df['Feriti'].sum()
n_morti = df['Morti'].sum()
self.assertTrue(n_incolumi == expected_incolumi, "Incolumi - check decode and count.")
self.assertTrue(n_feriti == expected_feriti, "Morti - check decode and count.")
self.assertTrue(n_morti == expected_morti, "Morti - check decode and count.")
pass
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test___calculate_incident_outcome_call_more_than_once(self):
try:
expected_incolumi = 7
expected_feriti = 4
expected_morti = 3
result_df = self.aggregator._IncidentsDataframeAggregator__calculate_incident_outcome()
self.assertTrue(result_df, "Must return the ok result.")
result_df = self.aggregator._IncidentsDataframeAggregator__calculate_incident_outcome()
self.assertTrue(result_df, "Must return the ok result.")
df = self.aggregator._IncidentsDataframeAggregator__df()
n_incolumi = df['Incolumi'].sum()
n_feriti = df['Feriti'].sum()
n_morti = df['Morti'].sum()
self.assertTrue(n_incolumi == expected_incolumi, "Incolumi - check decode and count.")
self.assertTrue(n_feriti == expected_feriti, "Morti - check decode and count.")
self.assertTrue(n_morti == expected_morti, "Morti - check decode and count.")
pass
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_count_of_incidents_by_typology
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], "convert_to_number": [],"incident_outcome_columns":["COL01","COL02","COL03"]}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Almenno", "Vimodrone"
],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "BG", "MI"],
"natura_incidente": [1, 1, 4, 10, 1, 4, 4],
}
incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(incidenti)
def test_get_count_of_incidents_by_typology_first_parameter(self):
try:
result_df = self.aggregator.get_count_of_incidents_by_typology(
"WRONG_FIRST_PARAMETER")
self.assertTrue(result_df is None,
"Wrong first parameter - return None.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_count_of_incidents_by_typology_nation_wide(self):
try:
expected_scontro_frontale = 3
expected_tamponamento = 3
expected_fuoriuscita = 1
result_df = self.aggregator.get_count_of_incidents_by_typology(
"nation_wide")
self.assertTrue(result_df is not None, "None return not allowed.")
result_df.set_index('descrizione', inplace=True)
scontro_frontale = result_df[['Numero']].loc['Scontro frontale'][0]
scontro_tamponamento = result_df[['Numero']].loc['Tamponamento'][0]
scontro_fuoriuscita = result_df[['Numero']].loc['Fuoriuscita'][0]
self.assertTrue(scontro_frontale == expected_scontro_frontale,
"Check count - scontro frontale.")
self.assertTrue(scontro_tamponamento == expected_tamponamento,
"Check count - tamponamento.")
self.assertTrue(scontro_fuoriuscita == expected_fuoriuscita,
"Check count - fuoriuscita.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_count_of_incidents_by_typology_province(self):
try:
expected_scontro_frontale = 1
expected_tamponamento = 1
expected_fuoriuscita = 1
provincia = "MI"
result_df = self.aggregator.get_count_of_incidents_by_typology(
"province", provincia)
self.assertTrue(result_df is not None, "None return not allowed.")
result_df.set_index('descrizione', inplace=True)
scontro_frontale = result_df[['Numero']].loc['Scontro frontale'][0]
scontro_tamponamento = result_df[['Numero']].loc['Tamponamento'][0]
scontro_fuoriuscita = result_df[['Numero']].loc['Fuoriuscita'][0]
self.assertTrue(
scontro_frontale == expected_scontro_frontale,
"Check count {prov} - scontro frontale.".format(
prov=provincia))
self.assertTrue(
scontro_tamponamento == expected_tamponamento,
"Check count {prov} - tamponamento.".format(prov=provincia))
self.assertTrue(
scontro_fuoriuscita == expected_fuoriuscita,
"Check count {prov} - fuoriuscita.".format(prov=provincia))
expected_scontro_frontale = 1
expected_tamponamento = 1
provincia = "BG"
result_df = self.aggregator.get_count_of_incidents_by_typology(
"province", provincia)
self.assertTrue(result_df is not None, "None return not allowed.")
result_df.set_index('descrizione', inplace=True)
scontro_frontale = result_df[['Numero']].loc['Scontro frontale'][0]
scontro_tamponamento = result_df[['Numero']].loc['Tamponamento'][0]
empty_fuoriuscita = 'Fuoriuscita' in result_df.index
self.assertTrue(
scontro_frontale == expected_scontro_frontale,
"Check count {prov} - scontro frontale.".format(
prov=provincia))
self.assertTrue(
scontro_tamponamento == expected_tamponamento,
"Check count {prov} - tamponamento.".format(prov=provincia))
self.assertTrue(
empty_fuoriuscita == False,
"Check count {prov} - fuoriuscita empty.".format(
prov=provincia))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_count_of_incidents_by_typology_not_existent_province(self):
try:
provincia = "DOES_NOT_EXIST"
result_df = self.aggregator.get_count_of_incidents_by_typology(
"province", provincia)
self.assertTrue(result_df.empty == True,
"An empty dataframe expected.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_count_of_incidents_by_typology_not_existent_comune(self):
try:
comune = "DOES_NOT_EXIST"
result_df = self.aggregator.get_count_of_incidents_by_typology(
"city", comune)
self.assertTrue(result_df.empty == True,
"An empty dataframe expected.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_count_of_incidents_by_typology_city(self):
try:
expected_scontro_frontale = 1
expected_tamponamento = 1
comune = "Como"
result_df = self.aggregator.get_count_of_incidents_by_typology(
"city", comune)
self.assertTrue(result_df is not None,
"A valid dataframe expected.")
result_df.set_index('descrizione', inplace=True)
scontro_frontale = result_df[['Numero']].loc['Scontro frontale'][0]
scontro_tamponamento = result_df[['Numero']].loc['Tamponamento'][0]
empty_fuoriuscita = 'Fuoriuscita' in result_df.index
self.assertTrue(
scontro_frontale == expected_scontro_frontale,
"Check count {city} - scontro frontale.".format(city=comune))
self.assertTrue(
scontro_tamponamento == expected_tamponamento,
"Check count {city} - tamponamento.".format(city=comune))
self.assertTrue(
empty_fuoriuscita == False,
"Check count {prov} - fuoriuscita empty.".format(prov=comune))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->calculate_total_incident_outcome
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone"
],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI"],
"COL01": [0, 1, 1, 1, 1, 4], # Incolume: 4, Morto: 1
"COL02": [4, 3, 1, 2, 2, 1], # Incolume: 2, Morto: 2, Ferito: 2
"COL03": [1, 1, 2, 2, 4, 1], # Incolume: 3, Morto: 1, Ferito: 2
"ODEA01": [0, 0, 2, 1, 0, 1], # 4
"OINJ01": [3, 0, 0, 0, 5, 0], # 8
"OINJ02": [6, 0, 1, 1, 0, 1] # 9
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_calculate_total_incident_outcome(self):
try:
expected_o_feriti = 17
expected_o_morti = 4
expected_incolumi = 9
expected_feriti = 4 + expected_o_feriti
expected_morti = 4 + expected_o_morti
result = self.aggregator.calculate_total_incident_outcome()
self.assertTrue(result, "Must return the OK code.")
injured_num = self.incidenti.df_incidenti["Feriti"].sum()
dead_num = self.incidenti.df_incidenti["Morti"].sum()
uninjured_num = self.incidenti.df_incidenti["Incolumi"].sum()
self.assertTrue(uninjured_num == expected_incolumi,
"Check totals - incolumi.")
self.assertTrue(dead_num == expected_morti,
"Check totals - morti.")
self.assertTrue(injured_num == expected_feriti,
"Check totals - feriti.")
other_injured = self.incidenti.df_incidenti["TotAltriFeriti"].sum()
other_dead = self.incidenti.df_incidenti["TotAltriMorti"].sum()
self.assertTrue(expected_o_feriti == other_injured,
"Chech partial - injured count.")
self.assertTrue(expected_o_morti == other_dead,
"Chech partial - dead count.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_calculate_total_incident_outcome_call_more_than_once(self):
try:
expected_o_feriti = 17
expected_o_morti = 4
expected_incolumi = 9
expected_feriti = 4 + expected_o_feriti
expected_morti = 4 + expected_o_morti
result = self.aggregator.calculate_total_incident_outcome()
self.assertTrue(result, "Must return the OK (1) code.")
result = self.aggregator.calculate_total_incident_outcome()
self.assertTrue(result, "Must return the OK (2) code.")
injured_num = self.incidenti.df_incidenti["Feriti"].sum()
dead_num = self.incidenti.df_incidenti["Morti"].sum()
uninjured_num = self.incidenti.df_incidenti["Incolumi"].sum()
self.assertTrue(uninjured_num == expected_incolumi,
"Check totals - incolumi.")
self.assertTrue(dead_num == expected_morti,
"Check totals - morti.")
self.assertTrue(injured_num == expected_feriti,
"Check totals - feriti.")
other_injured = self.incidenti.df_incidenti["TotAltriFeriti"].sum()
other_dead = self.incidenti.df_incidenti["TotAltriMorti"].sum()
self.assertTrue(expected_o_feriti == other_injured,
"Chech partial - injured count.")
self.assertTrue(expected_o_morti == other_dead,
"Chech partial - dead count.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
from src.ClassIncidenti import Incidenti
from src.ClassAnagraficaComuni import AnagraficaComuni
from src.ClassSupportDecodeDataframes import SupportDecodeDataframes
from src.ClassIncidentsDataframeAggregator import IncidentsDataframeAggregator
config = None
with open(config_file) as fconfig:
config = json.load(fconfig)
init_logger('/tmp', log_level=logging.FATAL, std_out_log_level=logging.FATAL)
base_dir = config['data_files']['data_path']
print(base_dir)
incidenti_fn = config['data_files']['file_incidenti']
incidenti_cols = config['data_structure']['columns']
cols_to_be_converted = config["data_structure"]["convert_to_number"]
anagrafica_comuni = AnagraficaComuni(
file_comuni_anagrafica=os.path.join(data_dir, istat_comuni_file))
support_dataframes = SupportDecodeDataframes()
incidenti = Incidenti(file_incidenti=os.path.join(data_dir, incidenti_fn),
anagrafica_comuni=anagrafica_comuni,
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
incidenti.load_data_files()
aggregator = IncidentsDataframeAggregator(incidenti)
("Vers. Incidenti:", Incidenti.get_version(), "Vers. Aggregator:",
IncidentsDataframeAggregator.get_version(), "Numerosita' df:",
incidenti.df_incidenti.shape[0])
class TestIncidentsDataframeAggregator_get_passengers_outcome(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_number_of_incidents_by_hour
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio","Roncolate", "Vimodrone" ,"Peschiera Borromeo"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004" ,"1005"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI" ,"MI"],
"COL01": [ 4, 2, 2, 1, 1, 3 ,2 ],
# COL01 -> Incolume: 2, Feriti: 2 ,Morto: 1+1
"COL02": [ 4, 2, 2, 1, 1, 3 ,1 ]
# COL02[MI] -> Incolume: 2, Feriti: 2 ,Morto: 1+1
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_get_passengers_outcome_unknown_area(self):
try:
result = self.aggregator.get_passengers_outcome(area="UNKNOWN", passenger_column="XXX")
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_city_none(self):
try:
result = self.aggregator.get_passengers_outcome(area="city", name=None, passenger_column="XXX")
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_column_none(self):
try:
result = self.aggregator.get_passengers_outcome(area="city", name="Vimodrone", passenger_column=None)
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_nation_wide_area(self):
try:
expected_results = {
"Incolume": 2,
"Ferito": 3,
"Morto nelle 24 ore": 1,
"Morto entro il trentesimo giorno": 1
}
result_df = self.aggregator.get_passengers_outcome("nation_wide", passenger_column="COL01")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results), "Check the number of found results.")
result_df = result_df[["descrizione","Numero"]]
result_df.set_index("descrizione", inplace=True)
for key in expected_results.keys():
self.assertTrue(result_df.loc[key]['Numero'] == expected_results[key], "Check key value {k}".format(k=key))
pass
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_nation_province(self):
try:
expected_results = {
"Incolume": 2,
"Morto nelle 24 ore": 1,
"Morto entro il trentesimo giorno": 1
}
result_df = self.aggregator.get_passengers_outcome("province", passenger_column="COL02", name="MI")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results), "Check the number of found results.")
result_df = result_df[["descrizione","Numero"]]
result_df.set_index("descrizione", inplace=True)
for key in expected_results.keys():
self.assertTrue(result_df.loc[key]['Numero'] == expected_results[key], "Check key value {k}".format(k=key))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_passengers_outcome_nation_city(self):
try:
expected_results = {
"Ferito": 2,
}
result_df = self.aggregator.get_passengers_outcome("city", passenger_column="COL02", name="Como")
self.assertTrue(result_df is not None, "None return not allowed.")
self.assertTrue(result_df.shape[0] == len(expected_results), "Check the number of found results.")
result_df = result_df[["descrizione","Numero"]]
result_df.set_index("descrizione", inplace=True)
for key in expected_results.keys():
self.assertTrue(result_df.loc[key]['Numero'] == expected_results[key], "Check key value {k}".format(k=key))
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator(TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_incidents_outcome_by_typology
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(file_incidenti = os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni = AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes = support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": ["Milano", "Como", "Como", "Cernusco Sul Naviglio","Roncolate", "Vimodrone"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004"],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI"],
"COL01": [ 0, 1, 1, 1, 1, 4], # Incolume: 4, Morto: 1
"COL02": [ 4, 3, 1, 2, 2, 1], # Incolume: 2, Morto: 2, Ferito: 2
"COL03": [ 1, 1, 2, 2, 4, 1], # Incolume: 3, Morto: 1, Ferito: 2
"ODEA01": [ 0, 0, 2, 1, 0, 1], # 4
"OINJ01": [ 3, 0, 0, 0, 5, 0], # 8
"OINJ02": [ 6, 0, 1, 1, 0, 1], # 9
"natura_incidente":[11, 1, 1, 2, 2, 1]
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_get_incidents_outcome_by_typology_unknown_area(self):
try:
result = self.aggregator.get_incidents_outcome_by_typology("UNKNOWN")
self.assertTrue(result is None, "No result must be returned.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_incidents_outcome_by_typology_nation_wide(self):
try:
fi_expected_feriti = 9
fi_expected_morti = 1
fi_expected_incolumi = 1
result_df = self.aggregator.get_incidents_outcome_by_typology("nation_wide")
self.assertTrue(result_df is not None, "Must be a valid dataframe.")
result_df.set_index('natura_incidente', inplace=True)
frenata_improvvisa = result_df.loc[11]
self.assertTrue(frenata_improvvisa['Morti'] == fi_expected_morti, "Check value for Morti.")
self.assertTrue(frenata_improvvisa['Feriti'] == fi_expected_feriti, "Check value for Feriti.")
self.assertTrue(frenata_improvvisa['Incolumi'] == fi_expected_incolumi, "Check value for Incolumi.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_incidents_outcome_by_typology_provincia(self):
try:
scf_expected_feriti = 3
scf_expected_morti = 1
scf_expected_incolumi = 1
result_df = self.aggregator.get_incidents_outcome_by_typology("province", "MI")
self.assertTrue(result_df is not None, "Must be a valid dataframe.")
result_df.set_index('natura_incidente', inplace=True)
scontro_front_lat = result_df.loc[2]
self.assertTrue(scontro_front_lat['Morti'] == scf_expected_morti, "Check value for Morti.")
self.assertTrue(scontro_front_lat['Feriti'] == scf_expected_feriti, "Check value for Feriti.")
self.assertTrue(scontro_front_lat['Incolumi'] == scf_expected_incolumi, "Check value for Incolumi.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_incidents_outcome_by_typology_city(self):
try:
scf_expected_feriti = 3
scf_expected_morti = 1
scf_expected_incolumi = 1
result_df = self.aggregator.get_incidents_outcome_by_typology("city", "Cernusco Sul Naviglio")
self.assertTrue(result_df is not None, "Must be a valid dataframe.")
result_df.set_index('natura_incidente', inplace=True)
scontro_front_lat = result_df.loc[2]
self.assertTrue(scontro_front_lat['Morti'] == scf_expected_morti, "Check value for Morti.")
self.assertTrue(scontro_front_lat['Feriti'] == scf_expected_feriti, "Check value for Feriti.")
self.assertTrue(scontro_front_lat['Incolumi'] == scf_expected_incolumi, "Check value for Incolumi.")
scf_expected_feriti = 2
scf_expected_morti = 3
scf_expected_incolumi = 4
result_df = self.aggregator.get_incidents_outcome_by_typology("city", "Como")
self.assertTrue(result_df is not None, "Must be a valid dataframe.")
result_df.set_index('natura_incidente', inplace=True)
scontro_front_lat = result_df.loc[1]
self.assertTrue(scontro_front_lat['Morti'] == scf_expected_morti, "Check value for Morti.")
self.assertTrue(scontro_front_lat['Feriti'] == scf_expected_feriti, "Check value for Feriti.")
self.assertTrue(scontro_front_lat['Incolumi'] == scf_expected_incolumi, "Check value for Incolumi.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
class TestIncidentsDataframeAggregator_get_number_of_incidents_by_provincia(
TestCase):
"""
Unit tests for the method:
- IncidentsDataframeAggregator->get_number_of_incidents_by_provincia
"""
def setUp(self) -> None:
self.__log = logging.getLogger('IncidentsDataframeAggregator')
s_config = '{"data_structure":{"columns":[], ' \
'"convert_to_number": [],' \
'"incident_outcome_columns":["COL01","COL02","COL03"],' \
'"other_injured_columns": ["OINJ01", "OINJ02"],' \
'"other_deadh_columns": ["ODEA01"]' \
'}}'
config = json.loads(s_config)
support_dataframes = SupportDecodeDataframes()
support_dataframes.load_dataframes()
self.incidenti = Incidenti(
file_incidenti=os.path.join("/fake_dir/", "fake_file_name.csv"),
anagrafica_comuni=AnagraficaComuni("/fake_dir/fake_filename.csv"),
support_dataframes=support_dataframes,
data_file_configurations=config["data_structure"])
test_df = {
"Comune": [
"Milano", "Como", "Como", "Cernusco Sul Naviglio", "Roncolate",
"Vimodrone", "Almenno"
],
"Provincia": ["MI", "CO", "CO", "MI", "BG", "MI", "AL"],
"comune": ["1001", "1000", "1000", "1002", "1003", "1004", "1005"]
}
self.incidenti.df_incidenti = pd.DataFrame.from_records(test_df)
self.aggregator = IncidentsDataframeAggregator(self.incidenti)
def test_get_number_of_incidents_by_provincia(self):
try:
expected_result = 3
result = self.aggregator.get_number_of_incidents_by_provincia("MI")
self.assertTrue(expected_result == result,
"Check the result for MI.")
expected_result = 1
result = self.aggregator.get_number_of_incidents_by_provincia("AL")
self.assertTrue(expected_result == result,
"Check the result for BG.")
expected_result = 2
result = self.aggregator.get_number_of_incidents_by_provincia("CO")
self.assertTrue(expected_result == result,
"Check the result for CO.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")
def test_get_number_of_incidents_by_provincia_not_existent(self):
try:
expected_result = 0
result = self.aggregator.get_number_of_incidents_by_provincia(
"DOES_NOT_EXIST")
self.assertTrue(expected_result == result,
"Check the result for DOES_NOT_EXIST.")
except Exception as ex:
self.fail("Exception received - but not expected - test fails.")