def _handle_request(request):
if persisted_state.database_instance().einzelbuchungen.anzahl() == 0:
return viewcore.generate_error_context('uebersicht_sparen', 'Bitte erfassen Sie zuerst eine Einzelbuchung.')
context = viewcore.generate_transactional_context('sparen')
kontos = persisted_state.database_instance().sparkontos.get_all().Kontoname.tolist()
typen = persisted_state.database_instance().sparkontos.KONTO_TYPEN
depot_typen = persisted_state.database_instance().depotwerte.TYPES
color_kontos = viewcore.get_generic_color_chooser(kontos)
color_typen = viewcore.get_generic_color_chooser(typen + depot_typen)
gesamt, kontos, typen = generate_konto_uebersicht(color_kontos, color_typen)
diagramm_uebersicht, year_kontostaende = gesamt_uebersicht()
gesamt_tabelle = berechne_gesamt_tabelle(year_kontostaende)
gesamt_diagramm_labels, gesamt_diagramm_data = berechne_diagramm(diagramm_uebersicht)
gesamt_linechart = berechne_kontogesamt(gesamt_tabelle)
order_until_today = persisted_state.database_instance().orderdauerauftrag.get_all_order_until_today()
context['kontos'] = kontos
context['typen'] = typen
context['gesamt'] = gesamt
context['monatlich'] = berechne_monatlich()
context['order_typ'] = berechne_order_typ(order_until_today)
context['general_infos'] = general_infos()
context['konto_diagramm'] = to_piechart(kontos, gesamt['wert'])
context['typen_diagramm'] = to_piechart(typen, gesamt['wert'])
context['gesamt_diagramm_labels'] = gesamt_diagramm_labels
context['gesamt_diagramm_data'] = gesamt_diagramm_data
context['gesamt_linechart'] = gesamt_linechart
return context
def set_up(self):
file_system.INSTANCE = FileSystemStub()
persisted_state.DATABASE_INSTANCE = None
depotwerte = persisted_state.database_instance().depotwerte
persisted_state.database_instance().sparkontos.add('demokonto', Kontos.TYP_DEPOT)
depotwerte.add(name='demowert', isin='demoisin', typ=depotwerte.TYP_ETF)
request_handler.stub_me()
def test_add():
set_up()
assert len(persisted_state.database_instance().depotauszuege.content) == 9
add_depotauszug.index(
VersionedPostRequest({
'action': 'add',
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '100,00',
'wert_2demokonto_3demoisin': '200,00'
}))
db = persisted_state.database_instance()
assert len(db.depotauszuege.content) == 11
buchungen = db.depotauszuege.get_by(datum('01.03.2020'), '2demokonto')
print(buchungen)
assert len(buchungen) == 2
assert buchungen.Wert[9] == 100
assert buchungen.Konto[9] == '2demokonto'
assert buchungen.Depotwert[9] == '2demoisin'
assert buchungen.Datum[9] == datum('01.03.2020')
assert buchungen.Wert[10] == 200
assert buchungen.Konto[10] == '2demokonto'
assert buchungen.Depotwert[10] == '3demoisin'
assert buchungen.Datum[10] == datum('01.03.2020')
def test_result_withLimitSelfAndValueOverLimit_shouldModifyVerhaeltnis(
self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, self_name)
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, name_partner)
result = gemeinsam_abrechnen.index(
PostRequest({
'set_verhaeltnis': 50,
'set_limit': 'on',
'set_limit_fuer': self_name,
'set_limit_value': 40
}))
assert result[
'ergebnis'] == 'Durch das Limit bei Test_User von 40 EUR wurde das Verhältnis von 50 auf 40.0 aktualisiert<br>Test_User bekommt von Partner noch 10.00€.'
assert result['self_soll'] == '40.00'
assert result['partner_soll'] == '60.00'
assert result['self_diff'] == '10.00'
assert result['partner_diff'] == '-10.00'
def test_gemeinsam_import_adde_passende_kategorie_should_import_value():
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
requester.INSTANCE = RequesterStub(
{
'https://test.test/gemeinsamebuchung.php':
_JSON_IMPORT_DATA_GEMEINSAM,
'https://test.test/deletegemeinsam.php': '',
'https://test.test/login.php': LOGIN_RESPONSE
},
DECODED_LOGIN_DATA,
auth_cookies=LOGIN_COOKIES)
context = import_data.index(
PostRequest({
'action': 'load_online_gemeinsame_transactions',
'email': '',
'server': 'test.test',
'password': ''
}))
assert context['element_titel'] == 'Export / Import'
assert len(database_instance().gemeinsamebuchungen.content) == 2
assert database_instance().gemeinsamebuchungen.get(
0)['Name'] == 'Testausgabe1'
assert database_instance().gemeinsamebuchungen.get(
0)['Person'] == 'TestUser'
assert database_instance().gemeinsamebuchungen.get(
1)['Name'] == 'Testausgabe2'
assert requester.instance().call_count_of(
'https://test.test/deletegemeinsam.php') == 1
assert requester.instance().complete_call_count() == 3
def test_edit_depotwert():
set_up()
typ_etf = persisted_state.database_instance().depotwerte.TYP_ETF
typ_fond = persisted_state.database_instance().depotwerte.TYP_FOND
add_depotwert.index(VersionedPostRequest(
{'action': 'add',
'name': '1name',
'isin': '1isin',
'typ': typ_etf
}
))
result = add_depotwert.index(VersionedPostRequest(
{'action': 'add',
'edit_index': 0,
'name': '2name',
'isin': '2isin',
'typ': typ_fond
}
))
db = persisted_state.database_instance()
assert len(db.depotwerte.content) == 1
assert db.depotwerte.content.Name[0] == '2name'
assert db.depotwerte.content.ISIN[0] == '2isin'
assert db.depotwerte.content.Typ[0] == typ_fond
result_element = list(result['letzte_erfassung'])[0]
assert result_element['fa'] == 'pencil'
assert result_element['Name'] == '2name'
assert result_element['Isin'] == '2isin'
assert result_element['Typ'] == typ_fond
def test_result_withLimitSelfAndValueUnderLimit_shouldReturnDefaultVerhaeltnis(
self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, self_name)
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, name_partner)
result = gemeinsam_abrechnen.index(
PostRequest({
'set_verhaeltnis': 50,
'set_limit': 'on',
'set_limit_fuer': self_name,
'set_limit_value': 100
}))
assert result[
'ergebnis'] == 'Die gemeinsamen Ausgaben sind ausgeglichen.'
assert result['self_soll'] == '50.00'
assert result['partner_soll'] == '50.00'
assert result['self_diff'] == '0.00'
assert result['partner_diff'] == '0.00'
def test_add_should_only_fire_once():
set_up()
typ_etf = persisted_state.database_instance().depotwerte.TYP_ETF
next_id = request_handler.current_key()
add_depotwert.index(PostRequest(
{'action': 'add',
'ID': next_id,
'name': '1name',
'isin': '1isin',
'typ': typ_etf
}
))
add_depotwert.index(PostRequest(
{'action': 'add',
'ID': next_id,
'name': 'overwritten',
'isin': 'overwritten',
'typ': ''
}
))
db = persisted_state.database_instance()
assert len(db.depotwerte.content) == 1
assert db.depotwerte.content.Name[0] == '1name'
assert db.depotwerte.content.ISIN[0] == '1isin'
assert db.depotwerte.content.Typ[0] == typ_etf
def general_infos():
kontos = persisted_state.database_instance().sparkontos.get_depots()
info = []
for konto in kontos:
latest_depotauszug = persisted_state.database_instance(
).depotauszuege.get_latest_datum_by(konto)
latest_order = get_last_order_for(konto)
warning = False
print('order', latest_order, 'auszug', latest_depotauszug)
if latest_order and latest_depotauszug and latest_depotauszug < latest_order:
warning = True
if not latest_order:
latest_order = ''
else:
latest_order = datum_to_german(latest_order)
if not latest_depotauszug:
latest_depotauszug = 'fehlend'
warning = True
else:
latest_depotauszug = datum_to_german(latest_depotauszug)
info.append({
'konto': konto,
'letzter_auszug': latest_depotauszug,
'letzte_order': latest_order,
'warning': warning
})
return {'kontos': info}
def _computePieChartProzentual(context, jahr):
result = database_instance(
).einzelbuchungen.get_jahresausgaben_nach_kategorie_prozentual(jahr)
ausgaben_data = []
ausgaben_labels = []
ausgaben_colors = []
kategorien = database_instance().einzelbuchungen.get_alle_kategorien()
color_chooser = viewcore.get_generic_color_chooser(list(kategorien))
for kategorie, wert in result.items():
ausgaben_data.append('%.2f' % abs(wert))
ausgaben_labels.append(kategorie)
ausgaben_colors.append(color_chooser.get_for_value(kategorie))
context['pie_ausgaben_data_prozentual'] = ausgaben_data
context['pie_ausgaben_labels'] = ausgaben_labels
context['pie_ausgaben_colors'] = ausgaben_colors
result = 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(color_chooser.get_for_value(kategorie))
context['pie_einnahmen_data_prozentual'] = einnahmen_data
context['pie_einnahmen_labels'] = einnahmen_labels
context['pie_einnahmen_colors'] = einnahmen_colors
return context
def test_edit():
set_up()
persisted_state.database_instance().depotauszuege = Depotauszuege()
add_depotauszug.index(
VersionedPostRequest({
'action': 'add',
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '100,00'
}))
result = add_depotauszug.index(
VersionedPostRequest({
'action': 'add',
'edit_index': 0,
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '200,00'
}))
db = persisted_state.database_instance()
assert len(db.depotauszuege.content) == 1
assert db.depotauszuege.content.Wert[0] == 200
assert db.depotauszuege.content.Konto[0] == '2demokonto'
assert db.depotauszuege.content.Depotwert[0] == '2demoisin'
assert db.depotauszuege.content.Datum[0] == datum('01.03.2020')
result_element = list(result['letzte_erfassung'])[0]
assert result_element['fa'] == 'pencil'
assert result_element['datum'] == '01.03.2020'
assert result_element['konto'] == '2demokonto'
assert result_element['depotwert'] == '2demoisin'
assert result_element['wert'] == '200,00'
def berechne_monatlich():
aktuelle_dauerauftraege = persisted_state.database_instance().orderdauerauftrag.aktuelle_raw().copy()
aktuelle_dauerauftraege = aktuelle_dauerauftraege[aktuelle_dauerauftraege.Wert > 0]
isins = set(aktuelle_dauerauftraege.Depotwert.tolist())
namen = []
colors = []
werte = []
monatlich = []
color_chooser = viewcore.get_generic_color_chooser(list(sorted(isins)))
for isin in sorted(isins):
name = persisted_state.database_instance().depotwerte.get_description_for(isin)
wert = get_sum(aktuelle_dauerauftraege[aktuelle_dauerauftraege.Depotwert == isin])
color = color_chooser.get_for_value(isin)
namen.append(name)
werte.append('%.2f' % wert)
colors.append(color)
monatlich.append({
'name': name,
'wert': from_double_to_german(wert),
'color': color
})
return {
'einzelwerte': monatlich,
'colors': colors,
'namen': namen,
'werte': werte
}
def add_test_data():
depotwerte = persisted_state.database_instance().depotwerte
depotwerte.add(name='depotwert1', isin='isin1', typ=depotwerte.TYP_ETF)
order = persisted_state.database_instance().order
order.add(datum_from_german('01.01.2020'), '1name', '1konto', 'isin1', 100)
order.add(datum_from_german('02.02.2020'), '2name', '2konto', 'isin1',
-200)
def add_test_data(self):
depotwerte = persisted_state.database_instance().depotwerte
depotwerte.add(name='depotwert1', isin='isin1')
depotwerte.add(name='depotwert2', isin='isin2')
order = persisted_state.database_instance().order
order.add(datum('12.12.2019'), 'demoname', 'demokonto', 'isin1', 100)
depotauszuege = persisted_state.database_instance().depotauszuege
depotauszuege.add(datum('01.01.2020'), 'isin1', 'demokonto', 90)
def _handle_request(request):
if post_action_is(request, 'delete'):
database_instance().gemeinsamebuchungen.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context('/gemeinsameuebersicht/')
context = viewcore.generate_transactional_context('gemeinsameuebersicht')
context['ausgaben'] = to_descriptive_list(
database_instance().gemeinsamebuchungen.select().to_list())
return context
def test_gemeinsam_add_passende_kategorie_should_import_value():
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
context = import_data.handle_request(PostRequest(
{'import': _IMPORT_DATA_GEMEINSAM}),
gemeinsam=True)
assert context['element_titel'] == 'Export / Import'
assert len(database_instance().gemeinsamebuchungen.content) == 2
def add_test_data(self):
depotauszuege = persisted_state.database_instance().depotauszuege
depotauszuege.add(datum('01.01.2020'), '1isin', '1demokonto', 1)
depotauszuege.add(datum('03.01.2020'), '2isin', '2demokonto', 2)
depotauszuege.add(datum('03.01.2020'), '3isin', '2demokonto', 3)
depotauszuege.add(datum('03.01.2020'), '4isin', '3demokonto', 4)
depotwerte = persisted_state.database_instance().depotwerte
depotwerte.add('1name', '1isin')
depotwerte.add('2name', '2isin')
depotwerte.add('3name', '3isin')
depotwerte.add('4name', '4isin')
def test_shortResult_withSelfMoreSpendings_shouldReturnEqualSentence(self):
self.set_up()
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
name_self = persisted_state.database_instance().name
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, name_self)
result = gemeinsam_abrechnen.index(GetRequest())
assert result[
'ergebnis'] == 'Test_User bekommt von Partner noch 5.50€.'
def handle_request(request):
if post_action_is(request, 'add'):
isin = request.values['isin']
if '_' in isin:
return viewcore.generate_error_context(
'add_depotwert', 'ISIN darf kein Unterstrich "_" enthalten.')
name = request.values['name']
if "edit_index" in request.values:
database_instance().depotwerte.edit(int(
request.values['edit_index']),
name=name,
isin=isin)
non_persisted_state.add_changed_depotwerte({
'fa': 'pencil',
'Name': name,
'Isin': isin
})
else:
database_instance().depotwerte.add(name=name, isin=isin)
non_persisted_state.add_changed_depotwerte({
'fa': 'plus',
'Name': name,
'Isin': isin
})
context = viewcore.generate_transactional_context('add_depotwert')
context['approve_title'] = 'Depotwert hinzufügen'
if post_action_is(request, 'edit'):
db_index = int(request.values['edit_index'])
db_row = database_instance().depotwerte.get(db_index)
default_item = {
'edit_index': str(db_index),
'name': db_row['Name'],
'isin': db_row['ISIN']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Depotwert aktualisieren'
if 'default_item' not in context:
context['default_item'] = {'name': '', 'isin': ''}
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_depotwerte())
return context
def test_add_with_empty_datum_should_return_error_page():
set_up()
persisted_state.database_instance().depotauszuege = Depotauszuege()
assert len(persisted_state.database_instance().depotauszuege.content) == 0
result = add_depotauszug.index(
VersionedPostRequest({
'action': 'add',
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '10,00',
'wert_2demokonto_3demoisin': '10,00'
}))
assert result['%Errortext'] == 'Interner Fehler <Kein Datum gefunden>.'
def test_gemeinsam_import_with_unpassenden_partnername_should_import_value_and_repalce_name(
):
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
requester.INSTANCE = RequesterStub(
{
'https://test.test/gemeinsamebuchung.php':
_JSON_IMPORT_DATA_GEMEINSAM_WRONG_PARTNER,
'https://test.test/deletegemeinsam.php': '',
'https://test.test/login.php': LOGIN_RESPONSE
},
DECODED_LOGIN_DATA,
auth_cookies=LOGIN_COOKIES)
context = import_data.index(
PostRequest({
'action': 'load_online_gemeinsame_transactions',
'email': '',
'server': 'test.test',
'password': ''
}))
assert context['element_titel'] == 'Export / Import'
assert len(database_instance().gemeinsamebuchungen.content) == 2
assert database_instance().gemeinsamebuchungen.get(0) == {
'Datum': datetime.date(2019, 7, 11),
'Dynamisch': False,
'Kategorie': 'Essen',
'Name': 'Testausgabe2',
'Person': 'TestUser',
'Wert': -0.9,
'index': 0
}
assert database_instance().gemeinsamebuchungen.get(1) == {
'Datum': datetime.date(2019, 7, 15),
'Dynamisch': False,
'Kategorie': 'Essen',
'Name': 'Testausgabe1',
'Person': 'Partner',
'Wert': -1.3,
'index': 1
}
assert requester.instance().call_count_of(
'https://test.test/deletegemeinsam.php') == 1
assert requester.instance().complete_call_count() == 3
def test_change_db_should_trigger_db_reload(self):
self.set_up()
configuration.index(
PostRequest({
'action': 'edit_databases',
'dbs': 'test'
}))
assert database_instance().name == 'test'
configuration.index(
PostRequest({
'action': 'edit_databases',
'dbs': 'test2'
}))
assert database_instance().name == 'test2'
def test_shortResult_withEqualValue_shouldReturnEqualSentence(self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, self_name)
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, name_partner)
result = gemeinsam_abrechnen.index(GetRequest())
assert result[
'ergebnis'] == 'Die gemeinsamen Ausgaben sind ausgeglichen.'
def test_upload_data_fehler():
set_up()
database_instance().gemeinsamebuchungen.add(datum('1.1.2020'),
'kategorie1', 'name1', 1.11,
'TestUser')
database_instance().gemeinsamebuchungen.add(datum('2.2.2020'),
'kategorie2', 'name2', 2.22,
'Partner')
requester.INSTANCE = RequesterStub(
{
'https://test.test/api/gemeinsamebuchung.php':
'{"result": "error"}',
'https://test.test/api/partner.php': _JSON_DATA_PARTNER,
'https://test.test/api/login.php': LOGIN_RESPONSE
},
DECODED_LOGIN_DATA,
auth_cookies=LOGIN_COOKIES)
result = import_data.index(
PostRequest({
'action': 'upload_gemeinsame_transactions',
'email': '',
'server': 'test.test/api',
'password': ''
}))
assert len(database_instance().gemeinsamebuchungen.content) == 2
assert result['message']
assert result['message_type'] == 'error'
assert result[
'message_content'] == 'Fehler beim Hochladen der gemeinsamen Buchungen.'
assert requester.INSTANCE.data_of_request(
'https://test.test/api/gemeinsamebuchung.php') == [[{
'datum': '2020-01-01',
'kategorie': 'kategorie1',
'name': 'name1',
'zielperson': 'online user name',
'wert': 1.11
}, {
'datum': '2020-02-02',
'kategorie': 'kategorie2',
'name': 'name2',
'zielperson': 'OnlinePartner',
'wert': 2.22
}]]
def test_delete(self):
self.set_up()
self.add_test_data()
uebersicht_depotauszuege.index(
VersionedPostRequest({
'action': 'delete',
'delete_index': '1'
}))
depotauszuege = persisted_state.database_instance().depotauszuege
assert len(depotauszuege.content) == 2
page_conent = uebersicht_depotauszuege._handle_request(GetRequest())
assert page_conent['gesamt'] == [
{
'buchungen': [{
'depotwert': '1name (1isin)',
'wert': 1
}],
'index': 0,
'name': '1demokonto vom 01.01.2020'
},
{
'buchungen': [{
'depotwert': '4name (4isin)',
'wert': 4
}],
'index': 1,
'name': '3demokonto vom 03.01.2020'
},
]
def test_add_should_only_fire_once(self):
self.set_up()
next_id = request_handler.current_key()
add_order.index(PostRequest(
{'action': 'add',
'ID': next_id,
'datum': rfc('1.1.2017'),
'name':'testname',
'wert':'2,00',
'typ': add_order.TYP_KAUF,
'depotwert': 'demoisin',
'konto': 'demokonto'
}
))
add_order.index(PostRequest(
{'action': 'add',
'ID': next_id,
'datum': rfc('2.2.2012'),
'name': 'overwritten',
'wert': '0,00',
'typ': add_order.TYP_KAUF,
'depotwert': 'overwritten',
'konto': 'overwritten'
}
))
db = persisted_state.database_instance()
assert len(db.order.content) == 1
assert db.order.content.Datum[0] == datum('1.1.2017')
assert db.order.content.Wert[0] == float('2.00')
assert db.order.content.Name[0] == 'testname'
assert db.order.content.Depotwert[0] == 'demoisin'
assert db.order.content.Konto[0] == 'demokonto'
def test_change_partnername_should_mirgrate_old_partnernames(self):
self.set_up()
name_of_partner = viewcore.name_of_partner()
gemeinsame_buchungen = 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 = database_instance().gemeinsamebuchungen
database_partners = gemeinsame_buchungen.content.Person
assert set(database_partners) == set(['testpartner_renamed'])
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_import_with_one_buchung_should_show_success_single_message():
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
context = import_data.index(PostRequest({'import': _IMPORT_DATA}))
assert context['message_content'] == '1 Buchung wurde importiert'
