def test_edit_dauerauftrag_ausgabe_to_einnahme(self):
self.set_up()
adddauerauftrag.index(
VersionedPostRequest({
'action': 'add',
'startdatum': rfc('1.1.2017'),
'endedatum': rfc('6.1.2017'),
'kategorie': 'Essen',
'typ': 'Ausgabe',
'rhythmus': 'monatlich',
'name': 'testname',
'wert': '2,00'
}))
adddauerauftrag.index(
VersionedPostRequest({
'action': 'add',
'edit_index': '0',
'startdatum': rfc('2.1.2017'),
'endedatum': rfc('5.1.2017'),
'kategorie': 'Essen',
'typ': 'Einnahme',
'rhythmus': 'monatlich',
'name': 'testname',
'wert': '2,50'
}))
assert len(db().dauerauftraege.content) == 1
assert db().dauerauftraege.content.Wert[0] == float('2.50')
assert db().dauerauftraege.content.Name[0] == 'testname'
assert db().dauerauftraege.content.Kategorie[0] == 'Essen'
assert db().dauerauftraege.content.Startdatum[0] == datum('2.1.2017')
assert db().dauerauftraege.content.Endedatum[0] == datum('5.1.2017')
def test_getContent_withEntries_shouldReturnListOfDicts(self):
component_under_test = Gemeinsamebuchungen()
component_under_test.add(
datum('1.1.2010'),
'kategorie1',
'name1',
1.23,
'person1')
component_under_test.add(
datum('2.2.2020'),
'kategorie2',
'name2',
3.45,
'person2')
assert component_under_test.select().to_list() == [
{
'index': 0,
'Datum': datum('01.01.2010'),
'Kategorie': 'kategorie1',
'Name': 'name1',
'Person': 'person1',
'Wert': 1.23
},
{
'index': 1,
'Datum': datum('02.02.2020'),
'Kategorie': 'kategorie2',
'Name': 'name2',
'Person': 'person2',
'Wert': 3.45
}
]
def test_drop_withMatchingIndex_shouldRemoveData(self):
component_under_test = Gemeinsamebuchungen()
component_under_test.add(
datum('1.1.2010'),
'kategorie1',
'name1',
1.23,
'person1')
component_under_test.add(
datum('2.2.2020'),
'kategorie2',
'name2',
3.45,
'person2')
component_under_test.drop([1])
assert component_under_test.select().to_list() == [
{
'index': 0,
'Datum': datum('01.01.2010'),
'Kategorie': 'kategorie1',
'Name': 'name1',
'Person': 'person1',
'Wert': 1.23
}
]
def teste_contextValues_withSingleEinnahmeAndSingleAusgabe(self):
self.set_up()
db = persisted_state.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_jahr.index(
PostRequest({
'date': '2010',
'mode': ''
}))
assert result_context['zusammenfassung_ausgaben'] == [[
'some kategorie', '-100.00', '#f56954'
]]
assert result_context['zusammenfassung_einnahmen'] == [[
'eine einnahme kategorie', '10.00', '#3c8dbc'
]]
assert 'eine einnahme kategorie' in result_context['einnahmen']
assert result_context['einnahmen']['eine einnahme kategorie'][
'values'] == '[10.00]'
assert result_context['jahre'] == [2010]
assert result_context['selected_date'] == 2010
def test_order_typ():
set_up()
sparkontos = persisted_state.database_instance().sparkontos
sparkontos.add(kontoname='demodepot1', kontotyp=sparkontos.TYP_DEPOT)
persisted_state.database_instance().depotwerte.add('demoname', 'demoisin')
persisted_state.database_instance().order.add(datum('01.01.2020'),
'testname', 'demodepot1',
'demoisin', 100)
persisted_state.database_instance().orderdauerauftrag.add(
datum('01.01.2020'),
datum('02.02.2020'),
name='1name',
rhythmus='monatlich',
depotwert='demoisin',
konto='demodepot1',
wert=33)
persisted_state.database_instance().refresh()
persisted_state.database_instance().einzelbuchungen.add(
datum('01.01.2020'), '1', '1', 1)
result = uebersicht_sparen.index(GetRequest())
assert result['order_typ'] == {
'manual': '100,00',
'dauerauftrag': '66,00',
'manual_raw': '100.00',
'dauerauftrag_raw': '66.00'
}
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_editCallFromUeberischt_presetValuesCorrect(self):
self.set_up()
db().dauerauftraege.add(datum('10.10.2010'), datum('10.10.2011'),
'0kategorie', '0name', 'monatlich', 10)
context = adddauerauftrag.index(
PostRequest({
'action': 'edit',
'edit_index': '0'
}))
assert context['approve_title'] == 'Dauerauftrag aktualisieren'
preset = context['default_item']
assert preset['Name'] == '0name'
assert preset['Startdatum'] == rfc('10.10.2010')
assert preset['Endedatum'] == rfc('10.10.2011')
assert preset['Kategorie'] == '0kategorie'
assert preset['Wert'] == '10,00'
assert preset['typ'] == 'Einnahme'
db().dauerauftraege.add(datum('10.10.2015'), datum('10.10.2015'),
'0kategorie', '0name', 'monatlich', -10)
context = adddauerauftrag.handle_request(
PostRequest({
'action': 'edit',
'edit_index': '1'
}))
preset = context['default_item']
assert preset['Startdatum'] == rfc('10.10.2015')
assert preset['Wert'] == '10,00'
assert preset['typ'] == 'Ausgabe'
def test_edit_shouldTaint(self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('1.1.2010'), 'some kategorie',
'some name', 1.23)
assert component_under_test.taint_number() == 1
component_under_test.edit(0, datum('2.1.2010'), 'some other kategorie',
'some other name', 2.34)
assert component_under_test.taint_number() == 2
def test_get_future_with_actual_dauerauftrag_should_return_empty():
component_under_test = Dauerauftraege()
component_under_test.add(datum('01.01.2012'), datum('01.01.2100'),
'some kategorie', 'some name', 'some rhythmus', 1)
result = component_under_test.future()
assert result == []
def test_get_aktuelle_with_past_dauerauftrag_should_return_empty_list():
component_under_test = Dauerauftraege()
component_under_test.add(datum('01.01.2012'), datum('01.01.2012'),
'some kategorie', 'some name', 'some rhythmus', 1)
result = component_under_test.aktuelle()
assert result == []
def test_get_latest_datum_by():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), 'demoisin', '1demokonto', 100)
component_under_test.add(datum('02.01.2020'), 'demoisin', '1demokonto', 200)
component_under_test.add(datum('03.01.2020'), 'demoisin', '2demokonto', 300)
assert component_under_test.get_latest_datum_by('1demokonto') == datum('02.01.2020')
def test_resolve_datum():
component_under_test = Depotauszuege()
component_under_test.add(datum('03.01.2020'), '1isin', '1demokonto', 11)
component_under_test.add(datum('07.01.2020'), '1isin', '2demokonto', 11)
component_under_test.add(datum('01.01.2020'), '1isin', '3demokonto', 11)
assert component_under_test.resolve_datum(1) == datum('03.01.2020')
def test_get_einzelbuchungen_shouldReturnListSortedBy_Datum(self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('01.01.2012'), '1kategorie', '1name', 1)
component_under_test.add(datum('01.01.2011'), '1kategorie', '1name', 1)
component_under_test.add(datum('01.01.2013'), '1kategorie', '1name', 1)
assert component_under_test.get_all().Datum[0].year == 2011
assert component_under_test.get_all().Datum[1].year == 2012
assert component_under_test.get_all().Datum[2].year == 2013
def test_edit_should_taint():
component_under_test = Dauerauftraege()
component_under_test.add(datum('1.1.2010'), date.today(), 'some kategorie',
'some name', 'some rhythmus', 1.23)
assert component_under_test.taint_number() == 1
component_under_test.edit(0, datum('2.1.2010'), datum('3.1.2010'),
'some other kategorie', 'some other name',
'some other rhythmus', 2.34)
assert component_under_test.taint_number() == 2
def test_select_max_year():
component_under_test = Depotauszuege()
component_under_test.add(datum('03.01.2019'), '1isin', '1demokonto', 11)
component_under_test.add(datum('05.01.2020'), '1isin', '1demokonto', 12)
component_under_test.add(datum('03.01.2021'), '1isin', '1demokonto', 99)
component_under_test.add(datum('03.01.2022'), '1isin', '1demokonto', 99)
assert component_under_test.select_max_year(2020).get_kontostand_by('1demokonto') == 12
def teste_durchschnittliche_ausgaben_pro_monat_mitNurLetztemMonat_sollteAusgabenDurchEinsTeilen(
self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('10.8.2011'), 'A', '', -10)
assert component_under_test.durchschnittliche_ausgaben_pro_monat(
2011, today=datum('10.9.2011')) == {
'A': '10.00'
}
def test_get_kontostand_by_():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), '1isin', 'demokonto', 10)
component_under_test.add(datum('02.01.2020'), '1isin', 'demokonto', 200)
component_under_test.add(datum('02.01.2020'), '2isin', 'demokonto', 300)
component_under_test.add(datum('02.01.2020'), '1isin', '1demokonto', 999)
assert component_under_test.get_kontostand_by('demokonto') == 500
def test_get_order_fuer(self):
component_under_test = Order()
component_under_test.add(datum('01.01.2020'), '1name', '1konto',
'1depotwert', 100)
component_under_test.add(datum('01.01.2020'), '1name', '2konto',
'1depotwert', 300)
assert component_under_test.get_order_fuer('1konto') == 100
def test_order_until_today_table_header_should_comply_order_table_header():
component_under_test = OrderDauerauftrag()
component_under_test.add(datum('01.01.2020'), datum('02.02.2020'),
'monatlich', '1name', '1konto', '1depotwert', 100)
result = component_under_test.get_all_order_until_today()
assert sorted(result.columns) == sorted(Order.TABLE_HEADER)
def teste_mitUnterschiedlichenMonaten_shouldSelectNeusterMonat(self):
self.set_up()
db = persisted_state.database_instance()
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie', 'some name', -100)
db.einzelbuchungen.add(datum('10.10.2011'), 'eine einnahme kategorie', 'some name', 10)
result_context = uebersicht_monat.index(GetRequest())
assert result_context['selected_date'] == '2011_10'
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 test_add_should_add():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), 'demoisin', 'demokonto', 100)
assert len(component_under_test.content) == 1
assert component_under_test.content.Datum[0] == datum('01.01.2020')
assert component_under_test.content.Depotwert[0] == 'demoisin'
assert component_under_test.content.Konto[0] == 'demokonto'
assert component_under_test.content.Wert[0] == 100
def test_group_by_kategorie_shouldGroupValues(self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('20.01.1990'), 'A', '', -10)
component_under_test.add(datum('20.01.1990'), 'A', '', -10)
component_under_test.add(datum('20.01.1990'), 'B', '', 8)
assert component_under_test.select().group_by_kategorie().Wert.tolist(
) == [-20, 8]
assert component_under_test.select().group_by_kategorie().index.tolist(
) == ['A', 'B']
def test_get_einzelbuchungen_shouldReturnListSortedBy_Datum_Kategorie_Name(
self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('01.01.2011'), '1kategorie', '1name', 1)
component_under_test.add(datum('01.01.2011'), '1kategorie', '3name', 1)
component_under_test.add(datum('01.01.2011'), '1kategorie', '2name', 1)
assert component_under_test.get_all().Name[0] == '1name'
assert component_under_test.get_all().Name[1] == '2name'
assert component_under_test.get_all().Name[2] == '3name'
def teste_durchschnittliche_ausgaben_pro_monat_withMatchingAndClosedYear_shouldReturnMonthlyPart(
self):
component_under_test = Einzelbuchungen()
component_under_test.add(datum('10.10.2010'), 'K', '', -10)
component_under_test.add(datum('10.10.2011'), 'K', '', -12)
assert component_under_test.durchschnittliche_ausgaben_pro_monat(
2011) == {
'K': "1.00"
}
def test_order_until_today_with_date_in_future_should_be_empty():
component_under_test = OrderDauerauftrag()
component_under_test.add(datum('01.01.3020'), datum('01.01.3021'),
'monatlich', 'future', '1konto', '1depotwert',
333)
result = component_under_test.get_all_order_until_today()
assert len(result) == 0
def test_order_until_today_with_invalid_dates_should_be_empty():
component_under_test = OrderDauerauftrag()
component_under_test.add(datum('01.01.2020'), datum('01.01.2019'),
'monatlich', 'invalid', '1konto', '1depotwert',
222)
result = component_under_test.get_all_order_until_today()
assert len(result) == 0
def test_get_depotwert_by():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), '1isin', '1demokonto', 11)
component_under_test.add(datum('02.01.2020'), '1isin', '1demokonto', 200)
component_under_test.add(datum('02.01.2020'), '2isin', '1demokonto', 311)
component_under_test.add(datum('02.01.2020'), '1isin', '2demokonto', 400)
assert component_under_test.get_depotwert_by('1isin') == 600
def test_select_max_year(self):
component_under_test = Sparbuchungen()
component_under_test.add(datum('01.01.2010'), '1name', 1, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('01.01.2011'), '1name', 1, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('01.01.2012'), '1name', 1, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('01.01.2013'), '1name', 33, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('01.01.2014'), '1name', 1, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
assert component_under_test.select_max_year(2013).get_aufbuchungen_fuer('konto') == 36
def test_get_aufbuchungen_fuer(self):
component_under_test = Sparbuchungen()
component_under_test.add(datum('01.01.2011'), '1name', 1, Sparbuchungen.TYP_AUSSCHUETTUNG, 'konto')
component_under_test.add(datum('02.02.2012'), '2name', 200, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('03.03.2013'), '3name', -50, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'konto')
component_under_test.add(datum('03.03.2013'), '3name', -3, Sparbuchungen.TYP_MANUELLER_AUFTRAG, 'anderes_konto')
component_under_test.add(datum('04.04.2014'), '4name', 10, Sparbuchungen.TYP_ZINSEN, 'konto')
assert component_under_test.get_aufbuchungen_fuer('konto') == 150
