def _handle_request(_):
name_self = viewcore.database_instance().name
name_partner = viewcore.name_of_partner()
ausgabe_sebastian = viewcore.database_instance().gemeinsamebuchungen.fuer(
name_self)
ausgabe_maureen = viewcore.database_instance().gemeinsamebuchungen.fuer(
name_partner)
ausgabe_sebastian = _sum(ausgabe_sebastian.Wert)
ausgabe_maureen = _sum(ausgabe_maureen.Wert)
ausgabe_gesamt = ausgabe_maureen + ausgabe_sebastian
dif_sebastian = (ausgabe_gesamt / 2) - ausgabe_sebastian
dif_maureen = (ausgabe_gesamt / 2) - ausgabe_maureen
ergebnis = 'Die gemeinsamen Ausgaben sind ausgeglichen.'
if dif_maureen > 0:
ergebnis = name_partner + ' bekommt von ' + name_self + ' noch ' + str(
'%.2f' % dif_maureen) + '€.'
if dif_sebastian > 0:
ergebnis = name_self + ' bekommt von ' + name_partner + ' noch ' + str(
'%.2f' % dif_sebastian) + '€.'
print("ergebnis:", ergebnis)
context = viewcore.generate_base_context('gemeinsamabrechnen')
context['ausgabe_maureen'] = "%.2f" % abs(ausgabe_maureen)
context['ausgabe_sebastian'] = "%.2f" % abs(ausgabe_sebastian)
context['ausgabe_gesamt'] = "%.2f" % abs(ausgabe_gesamt)
context['ergebnis'] = ergebnis
context['myname'] = name_self
context['partnername'] = name_partner
return context
def _computePieChartProzentual(context, jahr):
result = viewcore.database_instance(
).einzelbuchungen.get_jahresausgaben_nach_kategorie_prozentual(jahr)
ausgaben_data = []
ausgaben_labels = []
ausgaben_colors = []
for kategorie, wert in result.items():
ausgaben_data.append('%.2f' % abs(wert))
ausgaben_labels.append(kategorie)
ausgaben_colors.append('#' + viewcore.database_instance().
einzelbuchungen.get_farbe_fuer(kategorie))
context['pie_ausgaben_data_prozentual'] = ausgaben_data
context['pie_ausgaben_labels'] = ausgaben_labels
context['pie_ausgaben_colors'] = ausgaben_colors
result = viewcore.database_instance(
).einzelbuchungen.get_jahreseinnahmen_nach_kategorie_prozentual(jahr)
einnahmen_data = []
einnahmen_labels = []
einnahmen_colors = []
for kategorie, wert in result.items():
einnahmen_data.append('%.2f' % abs(wert))
einnahmen_labels.append(kategorie)
einnahmen_colors.append('#' + viewcore.database_instance().
einzelbuchungen.get_farbe_fuer(kategorie))
context['pie_einnahmen_data_prozentual'] = einnahmen_data
context['pie_einnahmen_labels'] = einnahmen_labels
context['pie_einnahmen_colors'] = einnahmen_colors
return context
def test_gemeinsamImport_withUnpassendenUsername_shouldImportValueAndRepalceName(
self):
self.set_up()
einzelbuchungen = viewcore.database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
requester.INSTANCE = RequesterStub({
'https://test.test/getgemeinsam.php':
self._IMPORT_DATA_GEMEINSAM_WRONG_SELF,
'https://test.test/deletegemeinsam.php':
'',
'https://test.test/getusername.php':
'Sebastian_Online'
})
context = import_data.index(
PostRequest({
'action': 'load_online_gemeinsame_transactions',
'email': '',
'server': 'test.test',
'password': ''
}))
assert context['element_titel'] == 'Export / Import'
assert len(
viewcore.database_instance().gemeinsamebuchungen.content) == 2
assert viewcore.database_instance(
).gemeinsamebuchungen.content.Person[0] == 'Sebastian'
assert viewcore.database_instance(
).gemeinsamebuchungen.content.Person[1] == 'Maureen'
assert requester.instance().call_count_of(
'https://test.test/deletegemeinsam.php') == 1
assert requester.instance().complete_call_count() == 3
def test_shortResult_withSelfMoreSpendings_shouldReturnEqualSentence(self):
self.set_up()
gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
name_self = viewcore.database_instance().name
gemeinsame_buchungen.add(datum('01.01.2010'), 'Some Cat.', 'Some Name',
-11, name_self)
result = gemeinsam_abrechnen.index(GetRequest())
assert result[
'ergebnis'] == 'Test_User bekommt von Maureen noch 5.50€.'
def _handle_abrechnen_request(_):
print("Abrechnen")
context = viewcore.generate_base_context('gemeinsamabrechnen')
abrechnungs_text = viewcore.database_instance().abrechnen()
context['abrechnungstext'] = abrechnungs_text.replace('\n', '<br>')
viewcore.database_instance().einzelbuchungen.taint()
viewcore.database_instance().gemeinsamebuchungen.taint()
return context
def test_editCallFromUeberischt_shouldNameButtonEdit(self):
self.set_up()
database_instance().einzelbuchungen.add(datum('10.10.2010'),
'kategorie', 'name', 10.00)
context = addausgabe.handle_request(
PostRequest({
'action': 'edit',
'edit_index': '0'
}))
assert context['approve_title'] == 'Ausgabe aktualisieren'
def test_gemeinsam_addePassendeKategorie_shouldImportValue(self):
self.set_up()
einzelbuchungen = viewcore.database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
html, context = import_data.handle_request(PostRequest(
{'import': self._IMPORT_DATA_GEMEINSAM}),
gemeinsam=True)
assert context['element_titel'] == 'Export / Import'
assert len(
viewcore.database_instance().gemeinsamebuchungen.content) == 2
def _handle_request(request):
if post_action_is(request, 'delete'):
print("Delete: ", request.values['delete_index'])
viewcore.database_instance().gemeinsamebuchungen.delete(int(request.values['delete_index']))
ausgaben_liste = []
data = viewcore.database_instance().gemeinsamebuchungen.content.sort_values(by='Datum')
for row_index, row in data.iterrows():
ausgaben_liste.append((row_index, row.Datum, row.Name, row.Kategorie, '%.2f' % row.Wert, row.Person))
context = viewcore.generate_base_context('gemeinsameuebersicht')
context['ausgaben'] = ausgaben_liste
context['transaction_key'] = 'requested'
return context
def test_change_db_should_trigger_db_reload(self):
self.set_up()
configuration.index(
PostRequest({
'action': 'edit_databases',
'dbs': 'test'
}))
assert viewcore.database_instance().name == 'test'
configuration.index(
PostRequest({
'action': 'edit_databases',
'dbs': 'test2'
}))
assert viewcore.database_instance().name == 'test2'
def test_add_should_only_fire_once(self):
self.set_up()
next_id = request_handler.current_key()
addgemeinsam.index(
PostRequest({
'action': 'add',
'ID': next_id,
'date': rfc('1.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'person': 'testperson',
'wert': '2,00'
}))
addgemeinsam.index(
PostRequest({
'action': 'add',
'ID': next_id,
'date': rfc('1.1.2017'),
'kategorie': 'overwritten',
'name': 'overwritten',
'person': 'overwritten',
'wert': '0,00'
}))
testdb = viewcore.database_instance()
assert testdb.gemeinsamebuchungen.content.Wert[0] == -1 * float('2.00')
assert testdb.gemeinsamebuchungen.content.Name[0] == 'testname'
assert testdb.gemeinsamebuchungen.content.Kategorie[0] == 'Essen'
assert testdb.gemeinsamebuchungen.content.Datum[0] == datum('1.1.2017')
assert testdb.gemeinsamebuchungen.content.Person[0] == 'testperson'
def teste_contextValues_withMutlibleEinnahmeAndAusgabe(self):
self.set_up()
db = viewcore.database_instance()
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
'some name', -100)
db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
'some name', 10)
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
'some name', -100)
db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
'some name', 10)
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie2',
'some name', -100)
db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie2',
'some name', 10)
result_context = uebersicht_jahr.index(
PostRequest({
'date': '2010',
'mode': ''
}))
assert result_context['zusammenfassung_ausgaben'] == [[
'some kategorie', '-200.00', '00a65a'
], ['some kategorie2', '-100.00', '00c0ef']]
assert result_context['zusammenfassung_einnahmen'] == [[
'eine einnahme kategorie', '20.00', '3c8dbc'
], ['eine einnahme kategorie2', '10.00', 'f56954']]
assert result_context['buchungen'][0]['wert'] == ['30.00']
assert result_context['buchungen'][1]['wert'] == ['300.00']
def teste_mitMehrAusgabenAlsEinnahmen(self):
self.set_up()
db = viewcore.database_instance()
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
'some name', -100)
db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
'some name', 10)
result_context = uebersicht_monat.index(
PostRequest({'date': '2010_10'}))
assert result_context['gesamt'] == '-100.00'
assert result_context['gesamt_einnahmen'] == '10.00'
assert result_context['einnahmen'] == [('eine einnahme kategorie',
'10.00', '3c8dbc')]
assert result_context['einnahmen_labels'] == [
'eine einnahme kategorie'
]
assert result_context['einnahmen_data'] == ['10.00']
assert result_context['ausgaben'] == [('some kategorie', '-100.00',
'f56954')]
assert result_context['ausgaben_labels'] == ['some kategorie']
assert result_context['ausgaben_data'] == ['100.00']
def test_isTainted_shouldReturnFalseWhenTainted(self):
self.set_up()
db = viewcore.database_instance()
assert not db.is_tainted()
db.taint()
assert db.is_tainted()
def test_tainNumber_shouldIncludeDauerauftraege(self):
self.set_up()
db = viewcore.database_instance()
assert db.taint_number() == 0
db.dauerauftraege.taint()
assert db.taint_number() == 1
def test_add_ausgabe_should_only_fire_once(self):
self.set_up()
request_key = request_handler.current_key()
addausgabe.index(
PostRequest({
'action': 'add',
'ID': request_key,
'date': rfc('1.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'wert': '2,00'
}))
addausgabe.index(
PostRequest({
'action': 'add',
'ID': request_key,
'date': rfc('1.1.2017'),
'kategorie': 'overwritten',
'name': 'overwritten',
'wert': '0,00'
}))
testdb = database_instance()
assert len(testdb.einzelbuchungen.content) == 1
assert testdb.einzelbuchungen.content.Wert[0] == -1 * float('2.00')
assert testdb.einzelbuchungen.content.Name[0] == 'testname'
assert testdb.einzelbuchungen.content.Kategorie[0] == 'Essen'
assert testdb.einzelbuchungen.content.Datum[0] == datum('1.1.2017')
def test_edit_ausgabe(self):
self.set_up()
addausgabe.handle_request(
VersionedPostRequest({
'action': 'add',
'date': rfc('1.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'wert': '2,00'
}))
addausgabe.handle_request(
VersionedPostRequest({
'action': 'add',
'edit_index': '0',
'date': rfc('5.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'wert': '2,50'
}))
testdb = database_instance()
assert len(testdb.einzelbuchungen.content) == 1
assert testdb.einzelbuchungen.content.Wert[0] == -1 * float('2.50')
assert testdb.einzelbuchungen.content.Name[0] == 'testname'
assert testdb.einzelbuchungen.content.Kategorie[0] == 'Essen'
assert testdb.einzelbuchungen.content.Datum[0] == datum('5.1.2017')
def test_change_partnername_should_mirgrate_old_partnernames(self):
self.set_up()
name_of_partner = viewcore.name_of_partner()
gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
gemeinsame_buchungen.add(datum('01.01.2017'), 'kat', 'name', 1,
name_of_partner)
configuration.index(
PostRequest({
'action': 'set_partnername',
'partnername': 'testpartner_renamed'
}))
gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
database_partners = gemeinsame_buchungen.content.Person
assert set(database_partners) == set(['testpartner_renamed'])
def _handle_request(_):
einzelbuchungen = viewcore.database_instance().einzelbuchungen
selector = einzelbuchungen.select()
ausgaben_liste = []
for row_index, row in selector.select_aktueller_monat().raw_table(
).iterrows():
ausgaben_liste.append({
'index': row_index,
'datum': datum_to_german(row.Datum),
'name': row.Name,
'kategorie': row.Kategorie,
'wert': '%.2f' % row.Wert
})
context = {
'zusammenfassung_monatsliste':
_monatsliste(),
'zusammenfassung_einnahmenliste':
_list_to_json(
selector.select_einnahmen().inject_zeros_for_last_6_months(
).select_letzte_6_montate().sum_monthly()),
'zusammenfassung_ausgabenliste':
_list_to_json(
selector.select_ausgaben().inject_zeros_for_last_6_months(
).select_letzte_6_montate().sum_monthly()),
'ausgaben_des_aktuellen_monats':
ausgaben_liste,
}
context = {**context, **viewcore.generate_base_context('dashboard')}
return context
def test_edit_ausgabe(self):
self.set_up()
addgemeinsam.index(
VersionedPostRequest({
'action': 'add',
'date': rfc('1.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'person': 'testperson',
'wert': '2,00'
}))
addgemeinsam.index(
PostRequest({
'action': 'add',
'ID': request_handler.current_key(),
'edit_index': '0',
'date': rfc('5.1.2017'),
'kategorie': 'Essen',
'name': 'testname',
'person': 'testperson2',
'wert': '2,50'
}))
testdb = viewcore.database_instance()
assert testdb.gemeinsamebuchungen.content.Wert[0] == -1 * float('2.50')
assert testdb.gemeinsamebuchungen.content.Name[0] == 'testname'
assert testdb.gemeinsamebuchungen.content.Kategorie[0] == 'Essen'
assert testdb.gemeinsamebuchungen.content.Datum[0] == datum('5.1.2017')
assert testdb.gemeinsamebuchungen.content.Person[0] == 'testperson2'
def test_tainNumber_shouldIncludeEinzelbuchungen(self):
self.set_up()
db = viewcore.database_instance()
assert db.taint_number() == 0
db.einzelbuchungen.taint()
assert db.taint_number() == 1
def test_personenOption_shouldContainNames(self):
self.set_up()
result = addgemeinsam.index(GetRequest())
assert viewcore.database_instance().name in result['personen']
assert viewcore.name_of_partner() in result['personen']
assert len(result['personen']) == 2
def test_taint_shouldIncreaseTaintNumber(self):
self.set_up()
db = viewcore.database_instance()
assert db.taint_number() == 0
db.taint()
assert db.taint_number() == 1
def _import(import_data, gemeinsam):
print('importing data:')
print(import_data)
if gemeinsam:
viewcore.database_instance().gemeinsamebuchungen.parse(import_data)
viewcore.database_instance().gemeinsamebuchungen.taint()
else:
viewcore.database_instance().einzelbuchungen.parse(import_data)
viewcore.database_instance().einzelbuchungen.taint()
def test_addePassendeKategorie_shouldImportValue(self):
self.set_up()
einzelbuchungen = viewcore.database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
context = import_data.index(PostRequest({'import': self._IMPORT_DATA}))
assert context['element_titel'] == 'Export / Import'
assert einzelbuchungen.select().select_year(2017).sum() == -11.54
def test_deTaint_shouldDeTaintEinzelbuchungen(self):
self.set_up()
db = viewcore.database_instance()
db.einzelbuchungen.taint()
assert db.is_tainted()
db.de_taint()
assert not db.is_tainted()
def set_up(self):
FileSystem.INSTANCE = FileSystemStub()
configuration_provider.LOADED_CONFIG = None
viewcore.DATABASE_INSTANCE = None
viewcore.DATABASES = []
print(viewcore.database_instance().name)
configuration_provider.set_configuration('PARTNERNAME', 'Maureen')
request_handler.stub_me()
def test_deTaint_shouldDeTaintDauerauftraege(self):
self.set_up()
db = viewcore.database_instance()
db.dauerauftraege.taint()
assert db.is_tainted()
db.de_taint()
assert not db.is_tainted()
def test_addeUnpassendenKategorie_shouldShowImportMappingPage(self):
self.set_up()
einzelbuchungen = viewcore.database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'unbekannt', 'some name',
-1.54)
context = import_data.index(PostRequest({'import': self._IMPORT_DATA}))
assert context['element_titel'] == 'Kategorien zuweisen'
def teste_datumsdarstellung_einzelbuchungsliste(self):
self.set_up()
db = viewcore.database_instance()
db.einzelbuchungen.add(datum('10.10.2011'), 'eine einnahme kategorie',
'some name', 10)
result_context = uebersicht_monat.index(GetRequest())
assert result_context['zusammenfassung'][0][0] == '10.10.2011'
def test_abrechnen(self):
self.set_up()
testdb = viewcore.database_instance()
testdb.gemeinsamebuchungen.add(datum('01.01.2010'), 'Eine Katgorie',
'Ein Name', 2.60, 'Eine Person')
gemeinsam_abrechnen.abrechnen(PostRequest({}))
assert testdb.einzelbuchungen.anzahl() == 1
assert testdb.einzelbuchungen.get_all().Wert[0] == '1.30'
