def test_load_data_filled():
file_system.INSTANCE = FileSystemStub()
file_system.instance().write(SHARES_PATH, '{"demo": 1234}')
result = load_data()
assert result.content == {'demo': 1234}
def write(database):
content = database.einzelbuchungen.get_static_content().to_csv(index=False)
content += wrap_tableheader(KEYWORD_DAUERAUFRTAEGE)
content += database.dauerauftraege.content.to_csv(index=False)
content += wrap_tableheader(KEYWORD_GEMEINSAME_BUCHUNGEN)
content += database.gemeinsamebuchungen.content.to_csv(index=False)
content += wrap_tableheader(KEYWORD_SPARBUCHUNGEN)
content += database.sparbuchungen.get_static_content().to_csv(index=False)
content += wrap_tableheader(KEYWORD_SPARKONTOS)
content += database.sparkontos.get_static_content().to_csv(index=False)
content += wrap_tableheader(KEYWORD_DEPOTWERTE)
content += database.depotwerte.get_static_content().to_csv(index=False)
content += wrap_tableheader(KEYWORD_ORDER)
content += database.order.get_static_content().to_csv(index=False)
content += wrap_tableheader(KEYWORD_ORDERDAUERAUFTRAG)
content += database.orderdauerauftrag.get_static_content().to_csv(
index=False)
content += wrap_tableheader(KEYWORD_DEPOTAUSZUEGE)
content += database.depotauszuege.get_static_content().to_csv(index=False)
file_system.instance().write(database_path_from(database.name), content)
print("WRITER: All Saved")
def teste_write_with_old_database_should_migrate(self):
self.mock_filesystem()
self.write_db_file_stub('testuser', self.full_db_old)
database = database_manager.read('testuser', set())
database_manager.write(database)
assert file_system.instance().read(
'../Database_testuser.csv') == file_system.instance(
).stub_pad_content(self.full_db)
def set_up(self):
file_system.INSTANCE = FileSystemStub()
file_system.instance().write(
file_system.ABRECHNUNG_PATH + '*Abrechnung_A',
self.ABRECHNUNG_A_CONTENT)
file_system.instance().write(file_system.IMPORT_PATH + '*Import_A',
self.IMPORT_A_CONTENT)
persisted_state.DATABASE_INSTANCE = None
request_handler.stub_me()
def read(nutzername, ausgeschlossene_kategorien):
if not file_system.instance().read(database_path_from(nutzername)):
neue_datenbank = Database(nutzername)
write(neue_datenbank)
file_content = file_system.instance().read(database_path_from(nutzername))
parser = DatabaseParser()
parser.from_string(file_content)
database = Database(nutzername,
ausgeschlossene_kategorien=ausgeschlossene_kategorien)
database.einzelbuchungen.parse(_to_table(parser.einzelbuchungen()))
print('READER: Einzelbuchungen gelesen')
database.dauerauftraege.parse(_to_table(parser.dauerauftraege()))
print('READER: Daueraufträge gelesen')
database.gemeinsamebuchungen.parse(_to_table(
parser.gemeinsame_buchungen()))
print('READER: Gemeinsame Buchungen gelesen')
if parser.sparkontos():
database.sparkontos.parse(_to_table(parser.sparkontos()))
print('READER: Sparkontos gelesen')
if parser.sparbuchungen():
database.sparbuchungen.parse(_to_table(parser.sparbuchungen()))
print('READER: Sparbuchungen gelesen')
if parser.depotwerte():
database.depotwerte.parse(_to_table(parser.depotwerte()))
print('READER: Depotwerte gelesen')
if parser.order():
database.order.parse(_to_table(parser.order()))
print('READER: Depotwerte gelesen')
if parser.depotauszuege():
database.depotauszuege.parse(_to_table(parser.depotauszuege()))
print('READER: Depotauszuege gelesen')
if parser.order_dauerauftrag():
database.orderdauerauftrag.parse(_to_table(
parser.order_dauerauftrag()))
print('READER: Order Dauerauftrag gelesen')
print('READER: Refreshe Database')
database.refresh()
print('READER: Refresh done')
return database
def test_import_should_write_into_abrechnungen():
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)
import_data.index(PostRequest({'import': _IMPORT_DATA}))
written_abrechnung = None
for key in file_system.instance()._fs_stub.keys():
if key.startswith('../Import'):
written_abrechnung = file_system.instance()._fs_stub[key]
assert written_abrechnung == _IMPORT_DATA
def test_alle_abrechnungen(self):
file_system.INSTANCE = FileSystemStub()
file_system.instance().write(file_system.ABRECHNUNG_PATH+'*Abrechnung_A', 'content abrechnung a')
file_system.instance().write(file_system.IMPORT_PATH+'*Import_A', 'content import a')
abrechnungen = file_system.all_abrechnungen()
assert abrechnungen == [
{
'content': ['content abrechnung a'],
'name': '../Abrechnungen/*Abrechnung_A'
},
{
'content': ['content import a'],
'name': '../Import/*Import_A'
}
]
def _load_config():
lines = file_system.instance().read(get_config_path() + '/config')
if not lines:
return dict(configuration_provider.DEFAULT_CONFIG)
loaded_config = {}
for line in lines:
if ':' in line:
line = line.strip()
loaded_config[line.split(':', 1)[0]] = line.split(':', 1)[1]
for key in dict(configuration_provider.DEFAULT_CONFIG):
if key not in loaded_config:
loaded_config[key] = configuration_provider.DEFAULT_CONFIG[key]
print("#####", loaded_config)
return loaded_config
def test_abrechnen_should_create_abrechnung_on_disk(self):
self.set_up()
testdb = persisted_state.database_instance()
testdb.gemeinsamebuchungen.add(datum('01.01.2010'), 'Eine Katgorie',
'Ein Name', 2.60, 'Eine Person')
gemeinsam_abrechnen.abrechnen(
PostRequest({
'set_mindate': '01.01.2010',
'set_maxdate': '01.01.2010',
'set_ergebnis': '%Ergebnis%',
'set_verhaeltnis': 50
}))
abrechnung = file_system.instance().read(
'../Abrechnungen/Abrechnung_2019-01-01 00:00:00')
assert abrechnung == [
'Abrechnung vom 01.01.2019 (01.01.2010-01.01.2010)\n',
'########################################\n', ' Ergebnis:\n',
'%Ergebnis%\n', '\n', 'Ausgaben von Partner 0.00\n',
'Ausgaben von Test_User 0.00\n',
'--------------------------------------\n',
'Gesamt 2.60\n', '\n', '\n',
'########################################\n',
' Gesamtausgaben pro Person \n',
'########################################\n',
' Datum Kategorie Name Wert\n',
'01.01.2010 Eine Katgorie Ein Name 1.30\n', '\n',
'\n', '########################################\n',
' Ausgaben von Partner\n',
'########################################\n',
' Datum Kategorie Name Wert\n', '\n',
'\n', '########################################\n',
' Ausgaben von Test_User\n',
'########################################\n',
' Datum Kategorie Name Wert\n', '\n',
'\n', '#######MaschinenimportStart\n',
'Datum,Kategorie,Name,Wert,Dynamisch\n',
'2010-01-01,Eine Katgorie,Ein Name,1.30,False\n',
'#######MaschinenimportEnd\n', ''
]
def write_db_file_stub(self, name, stub):
file_system.instance().write('../Database_' + name + '.csv', stub)
def save_if_needed(shares_data):
if not shares_data.is_changed():
return
file_system.instance().write(SHARES_PATH, json.dumps(shares_data.content))
def load_data():
data = file_system.instance().read(SHARES_PATH)
if not data:
return SharesInfo({})
return SharesInfo(json.loads(''.join(data)))
def _save_config(config):
content = []
for key in config:
content.append('{key}:{value}'.format(key=key, value=config[key]))
content = reduce(lambda x, y: str(x) + '\n' + str(y), content)
file_system.instance().write(get_config_path() + '/config', content)