def test_edit_should_edit():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), '1demoisin', '1demokonto', 100)
component_under_test.add(datum('02.02.2020'), '2demoisin', '2demokonto', 200)
component_under_test.add(datum('03.03.2020'), '3demoisin', '3demokonto', 300)
assert len(component_under_test.content) == 3
element_before = component_under_test.get(1)
assert element_before == {
'index': 1,
'Datum': datum('02.02.2020'),
'Depotwert': '2demoisin',
'Konto': '2demokonto',
'Wert': 200
}
component_under_test.edit(1, datum('03.02.2020'), '23demoisin', '23demokonto', 230)
assert len(component_under_test.content) == 3
element_after = component_under_test.get(1)
assert element_after == {
'index': 1,
'Datum': datum('03.02.2020'),
'Depotwert': '23demoisin',
'Konto': '23demokonto',
'Wert': 230
}
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_get_isins_invested_by_should_filter_invalid_isins():
component_under_test = Depotauszuege()
component_under_test.add(time.today(), 'too_long_12342342345', '2demokonto', 222)
component_under_test.add(time.today(), 'isin_1234567', '1demokonto', 111)
component_under_test.add(time.today(), 'too_short', '2demokonto', 333)
assert component_under_test.get_isins_invested_by() == ['isin_1234567']
def test_get_isins_invested_by_should_filter_out_not_invested_etfs_to_that_time():
component_under_test = Depotauszuege()
component_under_test.add(time.today(), '1isin1234567', '1demokonto', 1)
component_under_test.add(time.today() - timedelta(days=1), '2isin1234567', '2demokonto', 2)
component_under_test.add(time.today(), '2isin1234567', '2demokonto', 0)
assert component_under_test.get_isins_invested_by() == ['1isin1234567']
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 __init__(self, name, ausgeschlossene_kategorien=set()):
self.name = name
self.dauerauftraege = Dauerauftraege()
self.gemeinsamebuchungen = Gemeinsamebuchungen()
self.einzelbuchungen = Einzelbuchungen()
self.sparbuchungen = Sparbuchungen()
self.sparkontos = Kontos()
self.depotwerte = Depotwerte()
self.order = Order()
self.orderdauerauftrag = OrderDauerauftrag()
self.depotauszuege = Depotauszuege()
self.einzelbuchungen.ausgeschlossene_kategorien = ausgeschlossene_kategorien
self.tainted = 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_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 test_get_isins_invested_by_should_use_today_if_no_value_present():
component_under_test = Depotauszuege()
component_under_test.add(time.today(), '1isin1234567', '1demokonto', 1)
component_under_test.add(time.today() + timedelta(days=1), '2isin1234567', '2demokonto', 2)
assert component_under_test.get_isins_invested_by() == ['1isin1234567']
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_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_get_isins_invested_by_should_order_by_invested_value():
component_under_test = Depotauszuege()
component_under_test.add(time.today(), 'mid_12345678', '2demokonto', 222)
component_under_test.add(time.today(), 'small_123456', '1demokonto', 111)
component_under_test.add(time.today(), 'large_123456', '2demokonto', 333)
assert component_under_test.get_isins_invested_by() == ['large_123456', 'mid_12345678', 'small_123456']
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 test_exists_wert():
component_under_test = Depotauszuege()
assert not component_under_test.exists_wert(depotwert='isin1', konto='konto1')
component_under_test.add(datum('01.01.2020'), 'isin1', 'konto1', 100)
assert component_under_test.exists_wert(depotwert='isin1', konto='konto1')
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_init_with_empty_depotauszuege_should_flip_filled_and_empty():
set_up()
persisted_state.database_instance().depotauszuege = Depotauszuege()
context = add_depotauszug.index(GetRequest())
assert context['approve_title'] == 'Depotauszug hinzufügen'
assert context['default_items'] == [
{
'datum':
datum_to_string(date.today()),
'empty_items': [],
'filled_items': [{
'description': '1demowert (1demoisin)',
'isin': '1demoisin',
'wert': 0
}, {
'description': '2demowert (2demoisin)',
'isin': '2demoisin',
'wert': 0
}, {
'description': '3demowert (3demoisin)',
'isin': '3demoisin',
'wert': 0
}],
'konto':
'1demokonto'
},
{
'datum':
datum_to_string(date.today()),
'empty_items': [],
'filled_items': [{
'description': '1demowert (1demoisin)',
'isin': '1demoisin',
'wert': 0
}, {
'description': '2demowert (2demoisin)',
'isin': '2demoisin',
'wert': 0
}, {
'description': '3demowert (3demoisin)',
'isin': '3demoisin',
'wert': 0
}],
'konto':
'2demokonto'
},
]
def test_delete_depotauszug():
component_under_test = Depotauszuege()
component_under_test.add(datum('01.01.2020'), '1isin', '1demokonto', 1)
component_under_test.add(datum('03.01.2020'), '2isin', '2demokonto', 2)
component_under_test.add(datum('03.01.2020'), '3isin', '2demokonto', 3)
component_under_test.add(datum('03.01.2020'), '4isin', '3demokonto', 4)
assert len(component_under_test.content) == 4
component_under_test.delete_depotauszug(datum('03.01.2020'), '2demokonto')
assert len(component_under_test.content) == 2
assert component_under_test.content.index.tolist() == [0, 3]
assert component_under_test.content.Datum.tolist() == [datum('01.01.2020'), datum('03.01.2020')]
assert component_under_test.content.Depotwert.tolist() == ['1isin', '4isin']
assert component_under_test.content.Wert.tolist() == [1, 4]
def test_get_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('01.01.2020'), 'demoisin', '2demokonto', 300)
result = component_under_test.get_by(datum('01.01.2020'), '1demokonto')
assert len(result) == 1
assert result.index[0] == 0
assert result.Datum[0] == datum('01.01.2020')
assert result.Depotwert[0] == 'demoisin'
assert result.Konto[0] == '1demokonto'
assert result.Wert[0] == 100
def test_add_with_empty_value_should_skip():
set_up()
persisted_state.database_instance().depotauszuege = Depotauszuege()
assert len(persisted_state.database_instance().depotauszuege.content) == 0
add_depotauszug.index(
VersionedPostRequest({
'action': 'add',
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '0,00',
'wert_2demokonto_3demoisin': '0,00'
}))
db = persisted_state.database_instance()
assert len(db.depotauszuege.content) == 0
def test_edit_should_only_fire_once():
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'
}))
next_id = request_handler.current_key()
add_depotauszug.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '200,00'
}))
add_depotauszug.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'datum_2demokonto': rfc('01.03.2020'),
'konto': 'overwritten',
'wert_2demokonto_2demoisin': '0,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')
def test_get_kontostand_by_with_empty_should_return_zero():
component_under_test = Depotauszuege()
assert component_under_test.get_kontostand_by('demokonto') == 0
class Database:
def __init__(self, name, ausgeschlossene_kategorien=set()):
self.name = name
self.dauerauftraege = Dauerauftraege()
self.gemeinsamebuchungen = Gemeinsamebuchungen()
self.einzelbuchungen = Einzelbuchungen()
self.sparbuchungen = Sparbuchungen()
self.sparkontos = Kontos()
self.depotwerte = Depotwerte()
self.order = Order()
self.orderdauerauftrag = OrderDauerauftrag()
self.depotauszuege = Depotauszuege()
self.einzelbuchungen.ausgeschlossene_kategorien = ausgeschlossene_kategorien
self.tainted = 0
def taint(self):
self.tainted = self.tainted + 1
def is_tainted(self):
return self.taint_number() != 0
def taint_number(self):
return self.tainted + \
self.dauerauftraege.taint_number() + \
self.einzelbuchungen.taint_number() + \
self.gemeinsamebuchungen.taint_number() + \
self.sparbuchungen.taint_number() + \
self.sparkontos.taint_number() + \
self.depotwerte.taint_number() + \
self.order.taint_number() +\
self.depotauszuege.taint_number() +\
self.orderdauerauftrag.taint_number()
def refresh(self):
print('DATABASE: Erneuere Datenbestand')
alle_dauerauftragsbuchungen = self.dauerauftraege.get_all_einzelbuchungen_until_today(
)
self.einzelbuchungen.append_row(alle_dauerauftragsbuchungen)
anteil_gemeinsamer_buchungen = self.gemeinsamebuchungen.anteil_gemeinsamer_buchungen(
)
self.einzelbuchungen.append_row(anteil_gemeinsamer_buchungen)
anteil_sparbuchungen = self.sparbuchungen.get_dynamische_einzelbuchungen(
)
self.einzelbuchungen.append_row(anteil_sparbuchungen)
anteil_orderdauerauftrag = self.orderdauerauftrag.get_all_order_until_today(
)
self.order.append_row(anteil_orderdauerauftrag)
anteil_order = self.order.get_dynamische_einzelbuchungen()
self.einzelbuchungen.append_row(anteil_order)
print('DATABASE: Datenbestand erneuert')
def _write_trenner(self, abrechnunsdatei):
return abrechnunsdatei.write("".rjust(40, "#") + "\n ")
def abrechnen(self,
mindate,
maxdate,
set_ergebnis=None,
verhaeltnis=50,
set_self_kategorie=None,
set_other_kategorie=None):
selector = self.gemeinsamebuchungen.select().select_range(
mindate, maxdate)
name_self = persisted_state.database_instance().name
name_partner = viewcore.name_of_partner()
gemeinsame_buchungen_content = selector.content
select_partner = selector.fuer(name_partner)
select_self = selector.fuer(name_self)
summe_partner = select_partner.sum()
summe_self = select_self.sum()
ausgaben_gesamt = selector.sum()
abrechnunsdatei = StringWriter()
zeitraum = datum_to_german(mindate) + '-' + datum_to_german(maxdate)
abrechnunsdatei.write_line('Abrechnung vom ' +
datum_to_german(time.today()) + ' (' +
zeitraum + ')')
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write_line('Ergebnis:')
abrechnunsdatei.write_line(set_ergebnis)
abrechnunsdatei.write_empty_line()
self._write_large_table_row(abrechnunsdatei,
'Ausgaben von ' + name_partner,
summe_partner)
self._write_large_table_row(abrechnunsdatei,
'Ausgaben von ' + name_self, summe_self)
abrechnunsdatei.write_line("".ljust(38, "-"))
self._write_large_table_row(abrechnunsdatei, "Gesamt", ausgaben_gesamt)
if verhaeltnis == 50:
self.write_into_file(abrechnunsdatei,
selector.faktor(0.5).to_list(),
'Gesamtausgaben pro Person ')
self.write_into_file(abrechnunsdatei, select_partner.to_list(),
'Ausgaben von ' + name_partner)
self.write_into_file(abrechnunsdatei, select_self.to_list(),
'Ausgaben von ' + name_self)
ausgaben_fuer_partner = DataFrame()
faktor_partner = self._faktor_other(verhaeltnis)
ausgaben_fuer_self = DataFrame()
faktor_self = self._faktor_self(verhaeltnis)
summe_halb = selector.faktor(0.5).sum()
if set_self_kategorie:
faktor_self = 0.5
if set_other_kategorie:
faktor_partner = 0.5
for _, row in gemeinsame_buchungen_content.iterrows():
buchung_partner = self._berechne_abbuchung(
row['Datum'], row['Kategorie'], row['Name'],
("%.2f" % (row['Wert'] * faktor_partner)))
buchung_partner.Dynamisch = False
ausgaben_fuer_partner = pd.concat(
[ausgaben_fuer_partner, buchung_partner])
buchung_self = self._berechne_abbuchung(
row['Datum'], row['Kategorie'], row['Name'],
("%.2f" % (row['Wert'] * faktor_self)))
buchung_self.Dynamisch = False
ausgaben_fuer_self = pd.concat([ausgaben_fuer_self, buchung_self])
if set_self_kategorie:
extra_wert = (ausgaben_gesamt *
self._faktor_self(verhaeltnis)) - summe_halb
extra_ausgleichs_buchung = self._berechne_abbuchung(
maxdate, set_self_kategorie, set_self_kategorie,
("%.2f" % extra_wert))
extra_ausgleichs_buchung.Dynamisch = False
ausgaben_fuer_self = pd.concat(
[ausgaben_fuer_self, extra_ausgleichs_buchung])
if set_other_kategorie:
extra_wert = (ausgaben_gesamt *
self._faktor_other(verhaeltnis)) - summe_halb
extra_ausgleichs_buchung = self._berechne_abbuchung(
maxdate, set_other_kategorie, set_other_kategorie,
("%.2f" % extra_wert))
extra_ausgleichs_buchung.Dynamisch = False
ausgaben_fuer_partner = pd.concat(
[ausgaben_fuer_partner, extra_ausgleichs_buchung])
report = TextReportWriter().generate_report(
ausgaben_fuer_partner, abrechnunsdatei.to_string())
self.einzelbuchungen.append_row(ausgaben_fuer_self)
self.einzelbuchungen.taint()
self.gemeinsamebuchungen.drop(
gemeinsame_buchungen_content.index.tolist())
self.taint()
write_abrechnung("Abrechnung_" + str(time.now()), report)
return report
def _faktor_self(self, verhaeltnis):
return verhaeltnis / 100
def _faktor_other(self, verhaeltnis):
return self._faktor_self(100 - verhaeltnis)
def _write_large_table_row(self, abrechnunsdatei, name, summe):
abrechnunsdatei.write_line(
name.ljust(30, " ") + str("%.2f" % summe).rjust(7, " "))
def write_into_file(self, abrechnunsdatei, ausgaben, title):
abrechnunsdatei.write_empty_line(count=2)
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write_line(title)
self._write_trenner(abrechnunsdatei)
self._write_tabelle(abrechnunsdatei, ausgaben)
def _write_tabelle(self, writer, tabelle):
writer.write_line(
self._to_left("Datum", 10) + self._to_left(" Kategorie", 14) +
self._to_left("Name", 21) + self._to_right("Wert", 7))
for row in tabelle:
writer.write_line(
datum_to_german(row['Datum']) + " " +
row['Kategorie'].ljust(len("Kategorie "), " ") + " " +
row['Name'].ljust(20, " ") + " " +
str("%.2f" % (row['Wert'])).rjust(7, " "))
def _to_left(self, target_string, size):
return target_string.ljust(size, ' ')
def _to_right(self, target_string, size):
return target_string.rjust(size, ' ')
def _berechne_abbuchung(self, laufdatum, kategorie, name, wert):
return DataFrame([[laufdatum, kategorie, name, wert, True]],
columns=('Datum', 'Kategorie', 'Name', 'Wert',
'Dynamisch'))
def _row_to_dict(self, columns, index, row_data):
row = {'index': index}
for key in columns:
row[key] = row_data[key]
return row
def frame_to_list_of_dicts(self, dataframe):
result_list = []
for index, row_data in dataframe.iterrows():
row = self._row_to_dict(dataframe.columns, index, row_data)
result_list.append(row)
return result_list
def test_get_depotwert_by_with_empty_should_return_zero():
component_under_test = Depotauszuege()
assert component_under_test.get_depotwert_by('isin1') == 0
def test_resolve_index():
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('02.01.2020'), 'demoisin2', '1demokonto', 200)
component_under_test.add(datum('01.01.2020'), 'demoisin', '2demokonto', 300)
component_under_test.resolve_index(datum('01.01.2020'), '1demokonto', 'demoisin') == 0
component_under_test.resolve_index(datum('02.01.2020'), '1demokonto', 'demoisin') == 1
component_under_test.resolve_index(datum('02.01.2020'), '1demokonto', 'demoisin2') == 2
component_under_test.resolve_index(datum('01.01.2020'), '2demokonto', 'demoisin') == 3
def test_get_latest_datum_by_with_not_content_should_return_none():
component_under_test = Depotauszuege()
assert not component_under_test.get_latest_datum_by('1demokonto')
