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_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 = persisted_state.database_instance()
assert len(testdb.gemeinsamebuchungen.content) == 1
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 test_edit_depotwert_should_only_fire_once():
set_up()
add_depotwert.index(VersionedPostRequest(
{'action': 'add',
'name': '1name',
'isin': '1isin'
}
))
next_id = request_handler.current_key()
add_depotwert.index(PostRequest(
{'action': 'add',
'ID': next_id,
'edit_index': 0,
'name': '2name',
'isin': '2isin'
}
))
add_depotwert.index(PostRequest(
{'action': 'add',
'ID': next_id,
'edit_index': 0,
'name': 'overwritten',
'isin': 'overwritten'
}
))
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'
def test_edit_sparkonto_should_only_fire_once():
set_up()
add_sparkoto.index(
VersionedPostRequest({
'action': 'add',
'kontotyp': '1typ',
'kontoname': '1name'
}))
next_id = request_handler.current_key()
add_sparkoto.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'kontotyp': '2typ',
'kontoname': '2name'
}))
add_sparkoto.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'kontotyp': 'overwritten',
'kontoname': 'overwritten'
}))
db = persisted_state.database_instance()
assert len(db.sparkontos.content) == 1
assert db.sparkontos.content.Kontoname[0] == '2name'
assert db.sparkontos.content.Kontotyp[0] == '2typ'
def test_add_should_only_fire_once():
set_up()
next_id = request_handler.current_key()
add_depotauszug.index(
PostRequest({
'action': 'add',
'ID': next_id,
'datum_2demokonto': rfc('01.03.2020'),
'konto': '2demokonto',
'wert_2demokonto_2demoisin': '100,00'
}))
add_depotauszug.index(
PostRequest({
'action': 'add',
'ID': next_id,
'datum_2demokonto': rfc('01.03.2020'),
'konto': 'overwritten',
'wert_2demokonto_2demoisin': '9999,00'
}))
buchungen = persisted_state.database_instance().depotauszuege.content
assert len(buchungen) == 10
assert buchungen.Wert[9] == 100
assert buchungen.Konto[9] == '2demokonto'
assert buchungen.Depotwert[9] == '2demoisin'
assert buchungen.Datum[9] == datum('01.03.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_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 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_add_should_only_fire_once(self):
self.set_up()
next_id = request_handler.current_key()
add_sparbuchung.index(
PostRequest({
'action': 'add',
'ID': next_id,
'datum': rfc('1.1.2017'),
'name': 'testname',
'wert': '2,00',
'typ': Sparbuchungen.TYP_MANUELLER_AUFTRAG,
'eigenschaft': add_sparbuchung.EIGENSCHAFT_EINZAHLUNG,
'konto': 'demokonto'
}))
add_sparbuchung.index(
PostRequest({
'action': 'add',
'ID': next_id,
'datum': rfc('2.2.2012'),
'name': 'overwritten',
'wert': '0,00',
'typ': 'overwritten',
'eigenschaft': add_sparbuchung.EIGENSCHAFT_EINZAHLUNG,
'konto': 'overwritten'
}))
db = persisted_state.database_instance()
assert len(db.sparbuchungen.content) == 1
assert db.sparbuchungen.content.Datum[0] == datum('1.1.2017')
assert db.sparbuchungen.content.Wert[0] == float('2.00')
assert db.sparbuchungen.content.Name[0] == 'testname'
assert db.sparbuchungen.content.Typ[
0] == Sparbuchungen.TYP_MANUELLER_AUFTRAG
assert db.sparbuchungen.content.Konto[0] == 'demokonto'
def test_edit_should_only_fire_once():
set_up()
add_orderdauerauftrag.index(
VersionedPostRequest({
'action': 'add',
'startdatum': rfc('1.1.2017'),
'endedatum': rfc('1.1.2018'),
'rhythmus': 'monatlich',
'name': 'testname',
'wert': '2,00',
'typ': add_orderdauerauftrag.TYP_KAUF,
'depotwert': 'demoisin',
'konto': 'demokonto'
}))
next_id = request_handler.current_key()
add_orderdauerauftrag.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'startdatum': rfc('2.1.2017'),
'endedatum': rfc('2.1.2018'),
'rhythmus': 'monatlich',
'name': '2testname',
'wert': '3,00',
'typ': add_orderdauerauftrag.TYP_VERKAUF,
'depotwert': '2demoisin',
'konto': '2demokonto'
}))
add_orderdauerauftrag.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': 0,
'endedatum': rfc('1.1.2010'),
'startdatum': rfc('1.1.2010'),
'rhythmus': 'monatlich',
'name': 'overwritten',
'wert': '0,00',
'typ': add_orderdauerauftrag.TYP_KAUF,
'depotwert': 'overwritten',
'konto': 'overwritten'
}))
db = persisted_state.database_instance()
assert len(db.orderdauerauftrag.content) == 1
assert db.orderdauerauftrag.content.Startdatum[0] == datum('2.1.2017')
assert db.orderdauerauftrag.content.Endedatum[0] == datum('2.1.2018')
assert db.orderdauerauftrag.content.Rhythmus[0] == 'monatlich'
assert db.orderdauerauftrag.content.Wert[0] == float('-3.00')
assert db.orderdauerauftrag.content.Name[0] == '2testname'
assert db.orderdauerauftrag.content.Depotwert[0] == '2demoisin'
assert db.orderdauerauftrag.content.Konto[0] == '2demokonto'
def test_gemeinsam_import_with_unpassenden_kategorie_should_import_value_and_requestmapping(
):
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'KeinEssen', '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'] == 'Kategorien zuweisen'
assert context['import'] == _IMPORT_DATA_GEMEINSAM
assert context['unpassende_kategorien'] == ['Essen']
context = import_data.index(
PostRequest({
'action': 'map_and_push',
'Essen_mapping': 'neue Kategorie anlegen',
'import': _IMPORT_DATA_GEMEINSAM
}))
assert context['element_titel'] == 'Export / Import'
assert len(database_instance().gemeinsamebuchungen.content) == 2
assert database_instance(
).gemeinsamebuchungen.content.Person[0] == 'TestUser'
assert database_instance(
).gemeinsamebuchungen.content.Person[1] == 'Partner'
assert database_instance(
).gemeinsamebuchungen.content.Kategorie[0] == 'Essen'
assert database_instance(
).gemeinsamebuchungen.content.Kategorie[1] == 'Essen'
assert requester.instance().call_count_of(
'https://test.test/deletegemeinsam.php') == 1
assert requester.instance().complete_call_count() == 3
def test_edit_dauerauftrag_should_only_fire_once(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'
}))
next_id = request_handler.current_key()
adddauerauftrag.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': '0',
'startdatum': rfc('2.1.2017'),
'endedatum': rfc('5.1.2017'),
'kategorie': 'Essen',
'typ': 'Ausgabe',
'rhythmus': 'monatlich',
'name': 'testname',
'wert': '2,50'
}))
adddauerauftrag.index(
PostRequest({
'action': 'add',
'ID': next_id,
'edit_index': '0',
'startdatum': rfc('2.1.2017'),
'endedatum': rfc('5.1.2017'),
'kategorie': 'overwritten',
'typ': 'Ausgabe',
'rhythmus': 'overwritten',
'name': 'overwritten',
'wert': '0,00'
}))
assert len(db().dauerauftraege.content) == 1
assert db().dauerauftraege.content.Wert[0] == -1 * 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_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 teste_contextValues_withMutlibleEinnahmeAndAusgabe(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)
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 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_adde_unpassenden_kategorie_should_show_import_mapping_page():
set_up()
einzelbuchungen = database_instance().einzelbuchungen
einzelbuchungen.add(datum('01.01.2017'), 'unbekannt', 'some name', -1.54)
context = import_data.index(PostRequest({'import': _IMPORT_DATA}))
assert context['element_titel'] == 'Kategorien zuweisen'
def test_editCallFromUeberischt_shouldPresetValues_andRenameButton(self):
self.set_up()
add_sparbuchung.index(
VersionedPostRequest({
'action': 'add',
'datum': rfc('1.1.2017'),
'name': 'testname',
'wert': '2,00',
'typ': Sparbuchungen.TYP_MANUELLER_AUFTRAG,
'eigenschaft': add_sparbuchung.EIGENSCHAFT_EINZAHLUNG,
'konto': 'demokonto'
}))
context = add_sparbuchung.index(
PostRequest({
'action': 'edit',
'edit_index': '0'
}))
assert context['approve_title'] == 'Sparbuchung aktualisieren'
preset = context['default_item']
assert preset['edit_index'] == '0'
assert preset['datum'] == '2017-01-01'
assert preset['konto'] == 'demokonto'
assert preset['name'] == 'testname'
assert preset['wert'] == '2,00'
assert preset['eigenschaft'] == 'Einzahlung'
assert preset['typ'] == Sparbuchungen.TYP_MANUELLER_AUFTRAG
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_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_edit_call_from_ueberischt_should_preset_values_and_rename_button():
set_up()
context = add_depotauszug.index(
PostRequest({
'action': 'edit',
'edit_index': '8'
}))
assert context['approve_title'] == 'Depotauszug aktualisieren'
assert context['default_items'] == [{
'datum':
'2020-01-02',
'empty_items': [{
'description': '1demowert (1demoisin)',
'isin': '1demoisin',
'wert': 0
}],
'filled_items': [{
'description': '2demowert (2demoisin)',
'isin': '2demoisin',
'wert': 30
}, {
'description': '3demowert (3demoisin)',
'isin': '3demoisin',
'wert': 40
}],
'konto':
'2demokonto'
}]
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'
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_edit_call_from_ueberischt_should_preset_values_verkauf():
set_up()
add_orderdauerauftrag.index(
VersionedPostRequest({
'action': 'add',
'endedatum': rfc('1.1.2017'),
'startdatum': rfc('1.1.2018'),
'rhythmus': 'monatlich',
'name': 'testname',
'wert': '2,00',
'typ': add_orderdauerauftrag.TYP_VERKAUF,
'depotwert': 'demoisin',
'konto': 'demokonto'
}))
context = add_orderdauerauftrag.index(
PostRequest({
'action': 'edit',
'edit_index': '0'
}))
assert context['approve_title'] == 'Order-Dauerauftrag aktualisieren'
preset = context['default_item']
assert preset['wert'] == '2,00'
assert preset['typ'] == add_orderdauerauftrag.TYP_VERKAUF
def test_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.index(PostRequest({'import': _IMPORT_DATA}))
assert context['element_titel'] == 'Export / Import'
assert einzelbuchungen.select().select_year(2017).sum() == -11.54
def teste_gleitkommadarstellung_jahress_zusammenfassung(self):
self.set_up()
db = persisted_state.database_instance()
db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie', 'some name', -100)
result_context = uebersicht_monat.index(PostRequest({'date': '2010_10'}))
assert result_context['wert_uebersicht_jahr_gruppe_1'] == '0.00'
assert result_context['wert_uebersicht_jahr_gruppe_2'] == '100.00'
def test_change_partnername_should_change_partnername(self):
self.set_up()
assert viewcore.name_of_partner() == 'kein_Partnername_gesetzt'
configuration.index(
PostRequest({
'action': 'set_partnername',
'partnername': 'testpartner'
}))
assert viewcore.name_of_partner() == 'testpartner'
def test_addKategorie(self):
self.set_up()
configuration.index(
PostRequest({
'action': 'add_kategorie',
'neue_kategorie': 'test'
}))
assert database_instance().einzelbuchungen.get_alle_kategorien(
) == set(['test'])
def test_delete_should_only_fire_once():
set_up()
add_test_data()
next_id = request_handler.current_key()
assert len(persisted_state.database_instance().order.content) == 2
uebersicht_order.index(
PostRequest({
'action': 'delete',
'delete_index': '1',
'ID': next_id
}))
assert len(persisted_state.database_instance().order.content) == 1
uebersicht_order.index(
PostRequest({
'action': 'delete',
'delete_index': '1',
'ID': next_id
}))
assert len(persisted_state.database_instance().order.content) == 1
def test_http_exception(self):
self.set_up()
request_handler.stub_me()
result = request_handler.handle_request(
PostRequest({}), lambda x: self.raise_http_error(),
'something_normal')
assert result['message']
assert result['message_type'] == 'error'
assert result[
'message_content'] == 'Verbindung zum Server konnte nicht aufgebaut werden.'
def test_change_themecolor_should_change_themecolor(self):
self.set_up()
assert configuration_provider.get_configuration(
'THEME_COLOR') == '#00acd6'
configuration.index(
PostRequest({
'action': 'change_themecolor',
'themecolor': '#000000'
}))
assert configuration_provider.get_configuration(
'THEME_COLOR') == '#000000'