def test_controleSeriesOK(courbesTest):
"""
teste selection des courbes : valeurs OK
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Grandeurs calculées
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, True)
assert anneesOK == sorted(listAnnees)
assert nbCourbeOrig == len(courbesTest)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genereCode1Ville_OK(typeCode):
""" test génération des données pour une ville """
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Ville"
# Création répertoire de sortie hebergeant les villes
repVilles = config.get('Test', 'genCode.pathVilles')
if not os.path.isdir(repVilles):
os.mkdir(repVilles)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Test fonction de génération
genereCode1Ville.genereCode1Ville(config, connDB, repVilles, ville,
nomProg, typeCode, True, True)
# Fermeture base
database.closeDatabase(connDB, False)
def a_voir_test_genereCode1Ville_55(typeCode):
"""
test génération des données pour une ville du département 55
qui pose des problèmes au 21/11/2021 : donnees incompletes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Ville"
# Création répertoire de sortie hebergeant les villes
repVilles = config.get('Test', 'genCode.pathVilles55')
if not os.path.isdir(repVilles):
os.mkdir(repVilles)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini55')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini55')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('055039', 'BEAUMONT-EN-VERDUNOIS', 'Beaumont-en-Verdunois',
'Beaumont-en-Verdunois'), ))
connDB.commit()
# Création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVille = database.getListeVilles4Departement(connDB, '055', True)
ville = listeVille[0]
# Test fonction de génération
genereCode1Ville.genereCode1Ville(config, connDB, repVilles, ville,
nomProg, typeCode, True, True)
# Fermeture base
database.closeDatabase(connDB, False)
def test_calculeGrandeur(isWikicode):
"""
teste le calcule de grandeurs agglomérées
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], True)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], True)
assert len(listAnnees) == 3
# Test calcul des valeurs
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, True)
for grandeur in ["tendance ratio", "ratio dette / caf", "ratio n"]:
assert grandeur in dictAllGrandeur
# Fermeture base
database.closeDatabase(connDB, True)
def traiteDepartement(config, nomProg, isMatplotlibOk, connDB, resultatsPath,
verbose):
""" Récup et traitement des départements """
if verbose:
print("Entree dans traiteDepartement")
for departement in database.getListeDepartement(connDB, verbose):
print("===================\nTraitement du département", departement[0],
":", departement[2], "...")
# Création répertoire résultat pour ce département
repertoireDepBase = os.path.join(
resultatsPath,
config.get('EntreesSorties', 'io.repertoireBase') + '_' +
departement[0])
if not os.path.isdir(repertoireDepBase):
print("Creation repertoire du département :", repertoireDepBase)
os.makedirs(repertoireDepBase)
# Récup et traitement des villes du département
auMoins1villeGenere = False
listVilles = database.getListeVilles4Departement(
connDB, departement[0], verbose)
for ville in listVilles:
auMoins1villeGenere |= genereCode1Ville.traite1Ville(
config, ville, repertoireDepBase, connDB, nomProg,
isMatplotlibOk, verbose)
# Génération de l'index des villes
print("-------------")
if auMoins1villeGenere:
genHTML.genIndexHTML(config, repertoireDepBase, listVilles,
verbose)
print("\nOK : Resultats dans le repertoire :", repertoireDepBase)
print("Utilisez genIndexSite.py pour préparer le déploiment WEB.")
else:
print("Aucune commune générée !")
if verbose:
print("Sortie de traiteDepartement")
def test_genereTableau(isWikicode, isComplet):
"""
teste la génération des données tableau pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
nomTableau = "PRINCIPAL"
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
nbAnneesTableau = min(
int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
len(listAnnees))
couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
couleurSolde = config.get('Tableaux', 'tableaux.couleurSolde')
couleurRecettes = config.get('Tableaux', 'tableaux.couleurRecettes')
couleurCharges = config.get('Tableaux', 'tableaux.couleurCharges')
couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
couleurEmploisInvest = config.get('Tableaux',
'tableaux.couleurEmploisInvest')
couleurRessourcesInvest = config.get('Tableaux',
'tableaux.couleurRessourcesInvest')
verbose = True
listeValeurs = [
[
"total des produits de fonctionnement",
genCodeCommon.genLien(
config, ["Recettes publiques", "Produits de fonctionnement"],
isWikicode, verbose), couleurRecettes
],
[
"total des charges de fonctionnement",
genCodeCommon.genLien(
config, ["Dépenses publiques", "Charges de fonctionnement"],
isWikicode, verbose), couleurCharges
],
[
"resultat comptable",
genCodeCommon.genLien(config, [
"Résultat fiscal en France",
"Solde de la section de fonctionnement"
], isWikicode, verbose), couleurSolde
],
[
"total des emplois investissement",
genCodeCommon.genLien(config,
["Investissement", "Emplois investissement"],
isWikicode, verbose), couleurEmploisInvest
],
[
"total des ressources d'investissement",
genCodeCommon.genLien(
config, ["Investissement", "Ressources d'investissement"],
isWikicode, verbose), couleurRessourcesInvest
],
[
"besoin ou capacité de financement de la section investissement",
genCodeCommon.genLien(config, [
"Résultat fiscal en France",
"Solde de la section d'investissement"
], isWikicode, verbose), couleurSolde
],
]
# Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], verbose)
# Test de la generation tableau
if isWikicode:
ligne = genWikiCodeTableaux.genereTableau(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
else:
ligne = genHTMLCodeTableaux.genereTableau(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
# Test valeur des charges en 2015
# (cle charge) : 12659.65
assert "12660" in ligne
# Test valeur des charges par habitant en 2015
# (cle fcharge) : 858.63
assert "859" in ligne
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mcharge) : 1223.21
assert "1223" in ligne
def test_genereTableauTaux(isWikicode, isComplet):
"""
teste la génération des données tableau des taux
pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
nomTableau = "TAXES"
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
nbAnneesTableau = min(
int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
len(listAnnees))
couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
couleurTaxeHabitation = config.get('Tableaux',
'tableaux.couleurTaxeHabitation')
couleurTaxeFonciereBati = config.get('Tableaux',
'tableaux.couleurTaxeFonciereBati')
couleurTaxeFonciereNonBati = config.get(
'Tableaux', 'tableaux.couleurTaxeFonciereNonBati')
verbose = False
listeValeurs = [
[
"taux taxe habitation", "taux taxe d'habitation",
couleurTaxeHabitation
],
[
"taux taxe foncière bâti", "taux foncier bâti",
couleurTaxeFonciereBati
],
[
"taux taxe foncière non bâti", "taux foncier non bâti",
couleurTaxeFonciereNonBati
],
]
# Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], verbose)
# Test de la generation tableau
if isWikicode:
ligne = genWikiCodeTableaux.genereTableauTaux(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
else:
ligne = genHTMLCodeTableaux.genereTableauTaux(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
print("ligne=", ligne)
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10.11" in ligne
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "15.68" in ligne
def test_genCodeTableauxPicto(isComplet, isWikicode):
"""
teste la génération de tous les tableau pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, isWikicode, False)
# Lecture du modèle de test reduit au tableau picto
nomBaseModele = config.get('Test', 'genCodeTableauxPicto.ficModele')
typeSortie = ""
if isWikicode:
typeSortie = "wikicode"
else:
typeSortie = "HTML"
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
isGroupement = False
print("textSection AVANT genCodeTableauxPicto=", textSection)
# Définit le contenu des tableaux picto
grandeursAnalyse = genCodeTableaux.defTableauxPicto(config,
dictAllGrandeur, listAnnees,
isWikicode, False)
textSection = genCodeCommon.genCodeTableauxPicto(config,
dictAllGrandeur,
grandeursAnalyse,
textSection,
listAnnees, isComplet,
isWikicode,
True,
isGroupement,
False)
# Test Résultat comptable en 2015
# (cle fres1) : 12.94
print("textSection APRES genCodeTableauxPicto=", textSection)
assert "13" in textSection
# Test valeur des Charges de personnels par habitant en 2015
# (cle fperso) : 470.19
assert "470" in textSection
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mres1) : 131.95
assert "132" in textSection
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10" in textSection
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "16" in textSection
database.closeDatabase(connDB, True)
def test_getValeursDict(avecStrate):
""" Teste la fonction getValeursDict """
isWikicode = False
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
verbose = True
grandeursAnalyse = []
couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
dictEncoursDette = \
{
"l'encours de la dette" :
{
'libellePicto' : 'Encours de la dette',
'cle' : 'encours de la dette au 31 12 n',
'note' : "",
'noteHtml' : '',
'nul' : "pas d'encours pour la dette"
}
}
grandeursAnalyse.append([dictEncoursDette, 0, "ENCOURS_DETTE", couleurDettesCAF])
dictAnnuiteDette = \
{
"l'annuité de la dette" :
{
'libellePicto' : 'annuité de la dette',
'cle' : "annuité de la dette",
'note' : "",
'noteHtml' : '',
'nul' : 'aucune annuité pour la dette'
}
}
grandeursAnalyse.append([dictAnnuiteDette, 0, "ANNUITE_DETTE", couleurDettesCAF])
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V', ville[0], verbose)
nbAnneesTendance = int(config.get('GenWIkiCode', 'gen.nbAnneesTendance'))
listeAnneesTendance = sorted(listAnnees[:nbAnneesTendance])
for grandeurs in grandeursAnalyse:
genCodeCommon.getValeursDict(dictAllGrandeur,
listeAnneesTendance, listAnnees[0],
grandeurs[0], avecStrate,
verbose)
print(grandeurs[0], "=", grandeurs[0])
assert grandeurs[0]["l'encours de la dette"]['Valeur totale'] == 10817
assert grandeurs[0]["l'encours de la dette"]['Par habitant'] == 734
if avecStrate:
assert grandeurs[0]["l'encours de la dette"]['En moyenne pour la strate'] == 944
else:
assert not 'En moyenne pour la strate' in grandeurs[0]["l'encours de la dette"]
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2013] == pytest.approx(479.18)
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2014] == pytest.approx(671.41)
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2015] == pytest.approx(733.67)
break
def test_calculeGrandeurCleBesoin():
"""
teste le calcule de grandeurs agglomérées
"""
isWikicode = True
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Appel fonction à tester pour un ville
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)
print("Avant Suppression")
print("Valeur totale=", dictAllGrandeur['Valeur totale'].keys())
print("Par habitant=", dictAllGrandeur['Par habitant'].keys())
# Test valeur présente pour une ville et svg valeurs
cleManquante = "besoin ou capacité de financement de la section investissement"
cleManquanteHab = "besoin ou capacité de financement de la section investissement par habitant"
assert cleManquante in dictAllGrandeur['Valeur totale']
assert cleManquanteHab in dictAllGrandeur['Par habitant']
ValeursTotale = dictAllGrandeur['Valeur totale'][cleManquante]
ValeursHab = dictAllGrandeur['Par habitant'][cleManquanteHab]
cleRessourceInv = "total des ressources d'investissement"
assert cleRessourceInv in dictAllGrandeur['Valeur totale']
# Suppresion de la clé pour se mettre dans la situation d'un groupement de commune
del dictAllGrandeur['Valeur totale'][cleManquante]
del dictAllGrandeur['Par habitant'][cleManquanteHab]
assert cleManquante not in dictAllGrandeur['Valeur totale']
assert cleManquanteHab not in dictAllGrandeur['Par habitant']
# Appel fonction à tester pour un ville
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)
# Test valeur présente à nouveau pour une ville et controle valeurs
assert cleManquante in dictAllGrandeur['Valeur totale']
assert cleManquanteHab in dictAllGrandeur['Par habitant']
ValeursTotaleNew = dictAllGrandeur['Valeur totale'][cleManquante]
ValeursHabNew = dictAllGrandeur['Par habitant'][cleManquanteHab]
# Comparaison à un chouia près : 1e-3
assert ValeursTotale == pytest.approx(ValeursTotaleNew, rel=1e-3)
assert ValeursHab == pytest.approx(ValeursHabNew, rel=1e-3)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genCodeGraphiques_OK(isComplet, isWikicode):
""" Test la génération de tous les graphiques """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Création répertoire de sortie des graphiques
repOutGraphique = config.get('Test',
'genHTMLCodeGraphiques.pathOutputTest')
if not os.path.isdir(repOutGraphique):
os.mkdir(repOutGraphique)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Lecture du modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
typeSortie = config.get('GenCode', 'gen.idFicDetail')
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
# Generation des graphiques pour une ville
textSection = genCodeGraphiques.genCodeGraphiques(config, repOutGraphique,
dictAllGrandeur,
textSection, ville[1],
listAnnees, isComplet,
isWikicode, True, True)
# Test des valeurs générées
if isWikicode:
assert "Graphique polygonal" in textSection
else:
assert ".svg" in textSection
def test_controleSeriesSupprAll():
"""
teste selection des courbes :
suppression de toutes les courbes d'un graphique :
doit lever une exception ValueError
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Les courbee de clé "inconnue*" devront être supprimees
# et une exception levee
courbesTest = [
{
'cle': "inconnue1",
'sousCle': "Valeur totale",
},
{
'cle': "inconnue2",
'sousCle': "Valeur totale",
},
]
# Test calcul des valeurs
with pytest.raises(ValueError,
match=r'.*pas de courbe pour le graphique.*'):
genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, True)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genGraphique(courbesTest, nomGraphique, titreGrahique):
"""
teste generation de courbes pour sortie HTML
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Création répertoire de sortie des graphiques
repOutGraphique = config.get('Test', 'genHTMLCodeGraphiques.pathOutputTest')
if not os.path.isdir(repOutGraphique):
os.mkdir(repOutGraphique)
# Suppression fichier existant
nomImage = nomGraphique + '.svg'
cheminImage = os.path.join(repOutGraphique, nomImage)
if os.path.isfile(cheminImage):
print("Image précédente :", cheminImage)
os.remove(cheminImage)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, True, False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, False)
# Détermination de l'arrondi à utiliser et à afficher
listeCles = [courbe['cle']
for courbe in courbesTest
if courbe['sousCle'] == "Valeur totale"]
if listeCles:
arrondi, arrondiStr, arrondiStrAffiche = \
utilitaires.setArrondi(dictAllGrandeur["Valeur totale"], anneesOK,
1000.0, listeCles, False)
else:
arrondi = 1.0
arrondiStr = "%"
arrondiStrAffiche = arrondiStr
# Generation des graphiques HTML
textLien = \
genHTMLCodeGraphiques.genGraphique(repOutGraphique, dictAllGrandeur,
nomGraphique, titreGrahique, ville[1],
anneesOK, courbesTest,
arrondi, arrondiStrAffiche,
True)
assert nomGraphique in textLien
assert os.path.isfile(cheminImage)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genCodeTexte_func(typeCode):
"""
test la génération des données texte pour 1 ville : Wittenheim 68)
Choisir Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
print("pathDatabaseMini =", pathDatabaseMini)
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
print("pathCSVMini =", pathCSVMini)
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lecture et filtrage du fichier modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
numVersion = config.get('Version', 'version.number')
cle = ''
isWikicode = True
if typeCode == "wikiArticle":
cle = 'gen.idFicDetail'
isWikicode = True
elif typeCode == "HTML":
cle = 'gen.idFicHTML'
isWikicode = False
typeSortie = config.get('GenCode', cle)
modele = nomBaseModele + '_' + typeSortie + '.txt'
isComplet = (config.get('Modele', 'modele.type') == 'complet')
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales pour WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], True)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], True)
print("listAnnees =", listAnnees)
assert len(listAnnees) == 3
infosGroupement = ('200066041', 'Communauté de communes Sundgau',
'CC du Sundgau')
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
isWikicode, False)
# Test de la generation du texte
textSection = genCodeTexte.genTexte(config, dictAllGrandeur,
infosGroupement, modele, textSection,
ville, listAnnees, "test_genCodeTexte",
isWikicode, True)
assert "21547710" in textSection
if isWikicode:
# Vérification sources WEB dans texte généré
urlMinFi = config.get('Extraction', 'dataGouvFr.Comptes')
assert urlMinFi in textSection
urlMinFiVilles = config.get('Extraction', 'dataGouvFr.ComptesVilles')
assert urlMinFiVilles in textSection
if not isWikicode:
assert "Sundgau" in textSection
database.closeDatabase(connDB, False)
def test_genCodeTableauxWikicode(isComplet):
"""
teste la génération de tous les tableaux pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
isWikicode = True
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, isWikicode, False)
verbose = True
# Lecture du modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
typeSortie = config.get('GenCode', 'gen.idFicDetail')
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, verbose)
textSection = genCodeTableaux.genCodeTableaux(config, dictAllGrandeur,
textSection,
listAnnees, isComplet,
isWikicode, verbose)
# Test valeur des charges en 2015
# (cle charge) : 12659.65
assert "12660" in textSection
# Test valeur des charges par habitant en 2015
# (cle fcharge) : 858.63
assert "859" in textSection
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mcharge) : 1223.21
assert "1223" in textSection
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10" in textSection
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "16" in textSection
database.closeDatabase(connDB, True)
def test_genGraphique(courbesTest):
"""
teste generation de courbe
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, False)
# Détermination de l'arrondi à utiliser et à afficher
listeCles = [
courbe['cle'] for courbe in courbesTest
if courbe['sousCle'] == "Valeur totale"
]
if listeCles:
arrondi, arrondiStr, arrondiStrAffiche = \
utilitaires.setArrondi(dictAllGrandeur["Valeur totale"], anneesOK,
1000.0, listeCles, False)
else:
arrondi = 1.0
arrondiStr = "%"
arrondiStrAffiche = arrondiStr
# Generation des graphiques
graphiqueWiki, legendeVille, legendeStrate = \
genWikiCodeGraphiques.genGraphique(config, dictAllGrandeur,
ville[1], anneesOK,
courbesTest,
'graph.largeurPage',
arrondi,
arrondiStrAffiche,
True)
for annee in anneesOK:
assert str(annee) in graphiqueWiki
for courbe in courbesTest:
assert courbe['libelle'] in legendeVille
for courbe in courbesTest:
for annee in anneesOK:
if courbe['cle'].startswith('Taux'):
valeurData = \
round(dictAllGrandeur['Taux'][courbe['cle']][annee])
elif courbe['sousCle'] == "":
valeurData = round(dictAllGrandeur[courbe['cle']][annee])
else:
valeurData = round(
dictAllGrandeur[courbe['sousCle']][courbe['cle']][annee] *
arrondi)
assert str(valeurData) in graphiqueWiki
# Fermeture base
database.closeDatabase(connDB, True)
