Changed the properties of the test case from public to private.

This commit is contained in:
依瑪貓 2023-06-10 10:23:33 +08:00
parent 9930f33adb
commit c60424f763
11 changed files with 1069 additions and 1058 deletions

View File

@ -72,35 +72,35 @@ class AccountTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import Account, AccountL10n
AccountL10n.query.delete()
Account.query.delete()
db.session.commit()
self.encoded_next_uri: str = encode_next(NEXT_URI)
self.__encoded_next_uri: str = encode_next(NEXT_URI)
"""The encoded next URI."""
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
response: httpx.Response
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": CASH.title})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": CASH.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{CASH.code}")
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": BANK.base_code,
"title": BANK.title})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": BANK.base_code,
"title": BANK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{BANK.code}")
@ -111,7 +111,7 @@ class AccountTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import Account
client: httpx.Client = get_client(self.app, "nobody")
client: httpx.Client = get_client(self.__app, "nobody")
csrf_token: str = get_csrf_token(client)
response: httpx.Response
@ -146,12 +146,12 @@ class AccountTestCase(unittest.TestCase):
response = client.get(f"{PREFIX}/bases/{CASH.base_code}")
self.assertEqual(response.status_code, 403)
with self.app.app_context():
with self.__app.app_context():
cash_id: int = Account.find_by_code(CASH.code).id
response = client.post(f"{PREFIX}/bases/{CASH.base_code}",
data={"csrf_token": csrf_token,
"next": self.encoded_next_uri,
"next": self.__encoded_next_uri,
f"{cash_id}-no": "5"})
self.assertEqual(response.status_code, 403)
@ -161,7 +161,7 @@ class AccountTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import Account
client: httpx.Client = get_client(self.app, "viewer")
client: httpx.Client = get_client(self.__app, "viewer")
csrf_token: str = get_csrf_token(client)
response: httpx.Response
@ -196,12 +196,12 @@ class AccountTestCase(unittest.TestCase):
response = client.get(f"{PREFIX}/bases/{CASH.base_code}")
self.assertEqual(response.status_code, 200)
with self.app.app_context():
with self.__app.app_context():
cash_id: int = Account.find_by_code(CASH.code).id
response = client.post(f"{PREFIX}/bases/{CASH.base_code}",
data={"csrf_token": csrf_token,
"next": self.encoded_next_uri,
"next": self.__encoded_next_uri,
f"{cash_id}-no": "5"})
self.assertEqual(response.status_code, 403)
@ -213,48 +213,48 @@ class AccountTestCase(unittest.TestCase):
from accounting.models import Account
response: httpx.Response
response = self.client.get(PREFIX)
response = self.__client.get(PREFIX)
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/{CASH.code}")
response = self.__client.get(f"{PREFIX}/{CASH.code}")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/create")
response = self.__client.get(f"{PREFIX}/create")
self.assertEqual(response.status_code, 200)
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{STOCK.code}")
response = self.client.get(f"{PREFIX}/{CASH.code}/edit")
response = self.__client.get(f"{PREFIX}/{CASH.code}/edit")
self.assertEqual(response.status_code, 200)
response = self.client.post(f"{PREFIX}/{CASH.code}/update",
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-2"})
response = self.__client.post(f"{PREFIX}/{CASH.code}/update",
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{CASH.code}")
response = self.client.post(f"{PREFIX}/{BANK.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{BANK.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], PREFIX)
response = self.client.get(f"{PREFIX}/bases/{CASH.base_code}")
response = self.__client.get(f"{PREFIX}/bases/{CASH.base_code}")
self.assertEqual(response.status_code, 200)
with self.app.app_context():
with self.__app.app_context():
cash_id: int = Account.find_by_code(CASH.code).id
response = self.client.post(f"{PREFIX}/bases/{CASH.base_code}",
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri,
f"{cash_id}-no": "5"})
response = self.__client.post(f"{PREFIX}/bases/{CASH.base_code}",
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri,
f"{cash_id}-no": "5"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
@ -269,96 +269,97 @@ class AccountTestCase(unittest.TestCase):
detail_uri: str = f"{PREFIX}/{STOCK.code}"
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Account.query.all()},
{CASH.code, BANK.code})
# Missing CSRF token
response = self.client.post(store_uri,
data={"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 400)
# CSRF token mismatch
response = self.client.post(store_uri,
data={"csrf_token": f"{self.csrf_token}-2",
"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token":
f"{self.__csrf_token}-2",
"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 400)
# Empty base account code
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": " ",
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": " ",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Non-existing base account
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": "9999",
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "9999",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Unavailable base account
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": "1",
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "1",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Empty name
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": " "})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": " "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# A nominal account that needs offset
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": "6172",
"title": STOCK.title,
"is_need_offset": "yes"})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "6172",
"title": STOCK.title,
"is_need_offset": "yes"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Success, with spaces to be stripped
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": f" {STOCK.base_code} ",
"title": f" {STOCK.title} "})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": f" {STOCK.base_code} ",
"title": f" {STOCK.title} "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
# Success under the same base
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{STOCK.base_code}-002")
# Success under the same base, with order in a mess.
with self.app.app_context():
with self.__app.app_context():
stock_2: Account = Account.find_by_code(f"{STOCK.base_code}-002")
stock_2.no = 66
db.session.commit()
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{STOCK.base_code}-003")
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Account.query.all()},
{CASH.code, BANK.code, STOCK.code,
f"{STOCK.base_code}-002",
@ -381,71 +382,71 @@ class AccountTestCase(unittest.TestCase):
response: httpx.Response
# Success, with spaces to be stripped
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": f" {CASH.base_code} ",
"title": f" {CASH.title}-1 "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": f" {CASH.base_code} ",
"title": f" {CASH.title}-1 "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account: Account = Account.find_by_code(CASH.code)
self.assertEqual(account.base_code, CASH.base_code)
self.assertEqual(account.title_l10n, f"{CASH.title}-1")
# Empty base account code
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": " ",
"title": STOCK.title})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": " ",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Non-existing base account
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": "9999",
"title": STOCK.title})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "9999",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Unavailable base account
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": "1",
"title": STOCK.title})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "1",
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Empty name
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": " "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": " "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# A nominal account that needs offset
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": "6172",
"title": STOCK.title,
"is_need_offset": "yes"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": "6172",
"title": STOCK.title,
"is_need_offset": "yes"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Change the base account
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": STOCK.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_c_uri)
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 404)
response = self.client.get(detail_c_uri)
response = self.__client.get(detail_c_uri)
self.assertEqual(response.status_code, 200)
def test_update_not_modified(self) -> None:
@ -459,14 +460,14 @@ class AccountTestCase(unittest.TestCase):
account: Account
response: httpx.Response
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": f" {CASH.base_code} ",
"title": f" {CASH.title} "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": f" {CASH.base_code} ",
"title": f" {CASH.title} "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertIsNotNone(account)
account.created_at \
@ -474,14 +475,14 @@ class AccountTestCase(unittest.TestCase):
account.updated_at = account.created_at
db.session.commit()
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": STOCK.title})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": STOCK.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertIsNotNone(account)
self.assertLess(account.created_at,
@ -494,14 +495,14 @@ class AccountTestCase(unittest.TestCase):
"""
from accounting.models import Account
editor_username, admin_username = "editor", "admin"
client: httpx.Client = get_client(self.app, admin_username)
client: httpx.Client = get_client(self.__app, admin_username)
csrf_token: str = get_csrf_token(client)
detail_uri: str = f"{PREFIX}/{CASH.code}"
update_uri: str = f"{PREFIX}/{CASH.code}/update"
account: Account
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.created_by.username, editor_username)
self.assertEqual(account.updated_by.username, editor_username)
@ -513,7 +514,7 @@ class AccountTestCase(unittest.TestCase):
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.created_by.username,
editor_username)
@ -531,51 +532,51 @@ class AccountTestCase(unittest.TestCase):
account: Account
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.title_l10n, CASH.title)
self.assertEqual(account.l10n, [])
set_locale(self.app, self.client, self.csrf_token, "zh_Hant")
set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-zh_Hant"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-zh_Hant"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.title_l10n, CASH.title)
self.assertEqual({(x.locale, x.title) for x in account.l10n},
{("zh_Hant", f"{CASH.title}-zh_Hant")})
set_locale(self.app, self.client, self.csrf_token, "en")
set_locale(self.__app, self.__client, self.__csrf_token, "en")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-2"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.title_l10n, f"{CASH.title}-2")
self.assertEqual({(x.locale, x.title) for x in account.l10n},
{("zh_Hant", f"{CASH.title}-zh_Hant")})
set_locale(self.app, self.client, self.csrf_token, "zh_Hant")
set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-zh_Hant-2"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"base_code": CASH.base_code,
"title": f"{CASH.title}-zh_Hant-2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(CASH.code)
self.assertEqual(account.title_l10n, f"{CASH.title}-2")
self.assertEqual({(x.locale, x.title) for x in account.l10n},
@ -592,53 +593,53 @@ class AccountTestCase(unittest.TestCase):
list_uri: str = PREFIX
response: httpx.Response
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": PETTY.base_code,
"title": PETTY.title})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": PETTY.base_code,
"title": PETTY.title})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
add_journal_entry(self.client,
form={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri,
add_journal_entry(self.__client,
form={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri,
"date": dt.date.today().isoformat(),
"currency-1-code": "USD",
"currency-1-credit-1-account_code": BANK.code,
"currency-1-credit-1-amount": "20"})
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Account.query.all()},
{CASH.code, PETTY.code, BANK.code})
# Cannot delete the cash account
response = self.client.post(f"{PREFIX}/{CASH.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{CASH.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{CASH.code}")
# Cannot delete the account that is in use
response = self.client.post(f"{PREFIX}/{BANK.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{BANK.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{BANK.code}")
# Success
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 200)
response = self.client.post(delete_uri,
data={"csrf_token": self.csrf_token})
response = self.__client.post(delete_uri,
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], list_uri)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Account.query.all()},
{CASH.code, BANK.code})
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 404)
response = self.client.post(delete_uri,
data={"csrf_token": self.csrf_token})
response = self.__client.post(delete_uri,
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 404)
def test_change_base_code(self) -> None:
@ -650,15 +651,15 @@ class AccountTestCase(unittest.TestCase):
response: httpx.Response
for i in range(2, 6):
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": "1111",
"title": "Title"})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": "1111",
"title": "Title"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/1111-00{i}")
with self.app.app_context():
with self.__app.app_context():
account_1: Account = Account.find_by_code("1111-001")
id_1: int = account_1.id
account_2: Account = Account.find_by_code("1111-002")
@ -678,14 +679,14 @@ class AccountTestCase(unittest.TestCase):
account_5.no = 6
db.session.commit()
response = self.client.post(f"{PREFIX}/1111-005/update",
data={"csrf_token": self.csrf_token,
"base_code": "1112",
"title": "Title"})
response = self.__client.post(f"{PREFIX}/1111-005/update",
data={"csrf_token": self.__csrf_token,
"base_code": "1112",
"title": "Title"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/1112-003")
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(db.session.get(Account, id_1).no, 1)
self.assertEqual(db.session.get(Account, id_2).no, 3)
self.assertEqual(db.session.get(Account, id_3).no, 2)
@ -701,34 +702,34 @@ class AccountTestCase(unittest.TestCase):
response: httpx.Response
for i in range(2, 6):
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"base_code": "1111",
"title": "Title"})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"base_code": "1111",
"title": "Title"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/1111-00{i}")
# Normal reorder
with self.app.app_context():
with self.__app.app_context():
id_1: int = Account.find_by_code("1111-001").id
id_2: int = Account.find_by_code("1111-002").id
id_3: int = Account.find_by_code("1111-003").id
id_4: int = Account.find_by_code("1111-004").id
id_5: int = Account.find_by_code("1111-005").id
response = self.client.post(f"{PREFIX}/bases/1111",
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri,
f"{id_1}-no": "4",
f"{id_2}-no": "1",
f"{id_3}-no": "5",
f"{id_4}-no": "2",
f"{id_5}-no": "3"})
response = self.__client.post(f"{PREFIX}/bases/1111",
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri,
f"{id_1}-no": "4",
f"{id_2}-no": "1",
f"{id_3}-no": "5",
f"{id_4}-no": "2",
f"{id_5}-no": "3"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(db.session.get(Account, id_1).code, "1111-004")
self.assertEqual(db.session.get(Account, id_2).code, "1111-001")
self.assertEqual(db.session.get(Account, id_3).code, "1111-005")
@ -736,7 +737,7 @@ class AccountTestCase(unittest.TestCase):
self.assertEqual(db.session.get(Account, id_5).code, "1111-003")
# Malformed orders
with self.app.app_context():
with self.__app.app_context():
db.session.get(Account, id_1).no = 3
db.session.get(Account, id_2).no = 4
db.session.get(Account, id_3).no = 6
@ -744,16 +745,16 @@ class AccountTestCase(unittest.TestCase):
db.session.get(Account, id_5).no = 9
db.session.commit()
response = self.client.post(f"{PREFIX}/bases/1111",
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri,
f"{id_2}-no": "3a",
f"{id_3}-no": "5",
f"{id_4}-no": "2"})
response = self.__client.post(f"{PREFIX}/bases/1111",
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri,
f"{id_2}-no": "3a",
f"{id_3}-no": "5",
f"{id_4}-no": "2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(db.session.get(Account, id_1).code, "1111-003")
self.assertEqual(db.session.get(Account, id_2).code, "1111-004")
self.assertEqual(db.session.get(Account, id_3).code, "1111-002")

View File

@ -39,7 +39,7 @@ class BaseAccountTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
def test_nobody(self) -> None:
@ -47,7 +47,7 @@ class BaseAccountTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "nobody")
client: httpx.Client = get_client(self.__app, "nobody")
response: httpx.Response
response = client.get(LIST_URI)
@ -61,7 +61,7 @@ class BaseAccountTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "viewer")
client: httpx.Client = get_client(self.__app, "viewer")
response: httpx.Response
response = client.get(LIST_URI)
@ -75,7 +75,7 @@ class BaseAccountTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "editor")
client: httpx.Client = get_client(self.__app, "editor")
response: httpx.Response
response = client.get(LIST_URI)

View File

@ -40,10 +40,10 @@ class ConsoleCommandTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
# Drop every accounting table, to see if accounting-init recreates
# them correctly.
tables: list[sa.Table] \
@ -62,8 +62,8 @@ class ConsoleCommandTestCase(unittest.TestCase):
:return: None.
"""
runner: FlaskCliRunner = self.app.test_cli_runner()
with self.app.app_context():
runner: FlaskCliRunner = self.__app.test_cli_runner()
with self.__app.app_context():
result: Result = runner.invoke(
args=["accounting-init-db", "-u", "editor"])
self.assertEqual(result.exit_code, 0,
@ -88,7 +88,7 @@ class ConsoleCommandTestCase(unittest.TestCase):
for y in x if y.startswith("l10n-")}}
for x in csv.DictReader(fp)}
with self.app.app_context():
with self.__app.app_context():
accounts: list[BaseAccount] = BaseAccount.query.all()
self.assertEqual(len(accounts), len(data))
@ -109,7 +109,7 @@ class ConsoleCommandTestCase(unittest.TestCase):
"""
from accounting.models import BaseAccount, Account, AccountL10n
with self.app.app_context():
with self.__app.app_context():
bases: list[BaseAccount] = BaseAccount.query\
.filter(sa.func.char_length(BaseAccount.code) == 4).all()
accounts: list[Account] = Account.query.all()
@ -143,7 +143,7 @@ class ConsoleCommandTestCase(unittest.TestCase):
for y in x if y.startswith("l10n-")}}
for x in csv.DictReader(fp)}
with self.app.app_context():
with self.__app.app_context():
currencies: list[Currency] = Currency.query.all()
self.assertEqual(len(currencies), len(data))

View File

@ -65,32 +65,32 @@ class CurrencyTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import Currency, CurrencyL10n
CurrencyL10n.query.delete()
Currency.query.delete()
db.session.commit()
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
response: httpx.Response
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"code": USD.code,
"name": USD.name})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"code": USD.code,
"name": USD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{USD.code}")
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"code": EUR.code,
"name": EUR.name})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"code": EUR.code,
"name": EUR.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{EUR.code}")
@ -99,7 +99,7 @@ class CurrencyTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "nobody")
client: httpx.Client = get_client(self.__app, "nobody")
csrf_token: str = get_csrf_token(client)
response: httpx.Response
@ -136,7 +136,7 @@ class CurrencyTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "viewer")
client: httpx.Client = get_client(self.__app, "viewer")
csrf_token: str = get_csrf_token(client)
response: httpx.Response
@ -175,34 +175,34 @@ class CurrencyTestCase(unittest.TestCase):
"""
response: httpx.Response
response = self.client.get(PREFIX)
response = self.__client.get(PREFIX)
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/{USD.code}")
response = self.__client.get(f"{PREFIX}/{USD.code}")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/create")
response = self.__client.get(f"{PREFIX}/create")
self.assertEqual(response.status_code, 200)
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"code": TWD.code,
"name": TWD.name})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"code": TWD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{TWD.code}")
response = self.client.get(f"{PREFIX}/{USD.code}/edit")
response = self.__client.get(f"{PREFIX}/{USD.code}/edit")
self.assertEqual(response.status_code, 200)
response = self.client.post(f"{PREFIX}/{USD.code}/update",
data={"csrf_token": self.csrf_token,
"code": JPY.code,
"name": JPY.name})
response = self.__client.post(f"{PREFIX}/{USD.code}/update",
data={"csrf_token": self.__csrf_token,
"code": JPY.code,
"name": JPY.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{JPY.code}")
response = self.client.post(f"{PREFIX}/{EUR.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{EUR.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], PREFIX)
@ -217,72 +217,73 @@ class CurrencyTestCase(unittest.TestCase):
detail_uri: str = f"{PREFIX}/{TWD.code}"
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Currency.query.all()},
{USD.code, EUR.code})
# Missing CSRF token
response = self.client.post(store_uri,
data={"code": TWD.code,
"name": TWD.name})
response = self.__client.post(store_uri,
data={"code": TWD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 400)
# CSRF token mismatch
response = self.client.post(store_uri,
data={"csrf_token": f"{self.csrf_token}-2",
"code": TWD.code,
"name": TWD.name})
response = self.__client.post(store_uri,
data={"csrf_token":
f"{self.__csrf_token}-2",
"code": TWD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 400)
# Empty code
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": " ",
"name": TWD.name})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": " ",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Blocked code, with spaces to be stripped
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": " create ",
"name": TWD.name})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": " create ",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Bad code
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": " zzc ",
"name": TWD.name})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": " zzc ",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Empty name
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": TWD.code,
"name": " "})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": TWD.code,
"name": " "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Success, with spaces to be stripped
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": f" {TWD.code} ",
"name": f" {TWD.name} "})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": f" {TWD.code} ",
"name": f" {TWD.name} "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
# Duplicated code
response = self.client.post(store_uri,
data={"csrf_token": self.csrf_token,
"code": TWD.code,
"name": TWD.name})
response = self.__client.post(store_uri,
data={"csrf_token": self.__csrf_token,
"code": TWD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Currency.query.all()},
{USD.code, EUR.code, TWD.code})
@ -303,70 +304,70 @@ class CurrencyTestCase(unittest.TestCase):
response: httpx.Response
# Success, with spaces to be stripped
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": f" {USD.code} ",
"name": f" {USD.name}-1 "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": f" {USD.code} ",
"name": f" {USD.name}-1 "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency: Currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.code, USD.code)
self.assertEqual(currency.name_l10n, f"{USD.name}-1")
# Empty code
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": " ",
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": " ",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Blocked code, with spaces to be stripped
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": " create ",
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": " create ",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Bad code
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": "abc/def",
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": "abc/def",
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Empty name
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": TWD.code,
"name": " "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": TWD.code,
"name": " "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Duplicated code
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": EUR.code,
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": EUR.code,
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Change code
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": TWD.code,
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": TWD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_c_uri)
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 404)
response = self.client.get(detail_c_uri)
response = self.__client.get(detail_c_uri)
self.assertEqual(response.status_code, 200)
def test_update_not_modified(self) -> None:
@ -380,14 +381,14 @@ class CurrencyTestCase(unittest.TestCase):
currency: Currency | None
response: httpx.Response
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": f" {USD.code} ",
"name": f" {USD.name} "})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": f" {USD.code} ",
"name": f" {USD.name} "})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertIsNotNone(currency)
currency.created_at \
@ -395,14 +396,14 @@ class CurrencyTestCase(unittest.TestCase):
currency.updated_at = currency.created_at
db.session.commit()
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": USD.code,
"name": TWD.name})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": USD.code,
"name": TWD.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertIsNotNone(currency)
self.assertLess(currency.created_at,
@ -415,14 +416,14 @@ class CurrencyTestCase(unittest.TestCase):
"""
from accounting.models import Currency
editor_username, admin_username = "editor", "admin"
client: httpx.Client = get_client(self.app, admin_username)
client: httpx.Client = get_client(self.__app, admin_username)
csrf_token: str = get_csrf_token(client)
detail_uri: str = f"{PREFIX}/{USD.code}"
update_uri: str = f"{PREFIX}/{USD.code}/update"
currency: Currency
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.created_by.username, editor_username)
self.assertEqual(currency.updated_by.username, editor_username)
@ -434,7 +435,7 @@ class CurrencyTestCase(unittest.TestCase):
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.created_by.username, editor_username)
self.assertEqual(currency.updated_by.username, admin_username)
@ -446,14 +447,14 @@ class CurrencyTestCase(unittest.TestCase):
"""
response: httpx.Response
response = self.client.get(
response = self.__client.get(
f"/accounting/api/currencies/exists-code?q={USD.code}")
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertEqual(set(data.keys()), {"exists"})
self.assertTrue(data["exists"])
response = self.client.get(
response = self.__client.get(
f"/accounting/api/currencies/exists-code?q={USD.code}-1")
self.assertEqual(response.status_code, 200)
data = response.json()
@ -471,51 +472,51 @@ class CurrencyTestCase(unittest.TestCase):
currency: Currency
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.name_l10n, USD.name)
self.assertEqual(currency.l10n, [])
set_locale(self.app, self.client, self.csrf_token, "zh_Hant")
set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": USD.code,
"name": f"{USD.name}-zh_Hant"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": USD.code,
"name": f"{USD.name}-zh_Hant"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.name_l10n, USD.name)
self.assertEqual({(x.locale, x.name) for x in currency.l10n},
{("zh_Hant", f"{USD.name}-zh_Hant")})
set_locale(self.app, self.client, self.csrf_token, "en")
set_locale(self.__app, self.__client, self.__csrf_token, "en")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": USD.code,
"name": f"{USD.name}-2"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": USD.code,
"name": f"{USD.name}-2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.name_l10n, f"{USD.name}-2")
self.assertEqual({(x.locale, x.name) for x in currency.l10n},
{("zh_Hant", f"{USD.name}-zh_Hant")})
set_locale(self.app, self.client, self.csrf_token, "zh_Hant")
set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant")
response = self.client.post(update_uri,
data={"csrf_token": self.csrf_token,
"code": USD.code,
"name": f"{USD.name}-zh_Hant-2"})
response = self.__client.post(update_uri,
data={"csrf_token": self.__csrf_token,
"code": USD.code,
"name": f"{USD.name}-zh_Hant-2"})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
currency = db.session.get(Currency, USD.code)
self.assertEqual(currency.name_l10n, f"{USD.name}-2")
self.assertEqual({(x.locale, x.name) for x in currency.l10n},
@ -529,56 +530,56 @@ class CurrencyTestCase(unittest.TestCase):
from accounting.models import Currency
detail_uri: str = f"{PREFIX}/{JPY.code}"
delete_uri: str = f"{PREFIX}/{JPY.code}/delete"
with self.app.app_context():
with self.__app.app_context():
encoded_next_uri: str = encode_next(NEXT_URI)
list_uri: str = PREFIX
response: httpx.Response
response = self.client.post(f"{PREFIX}/store",
data={"csrf_token": self.csrf_token,
"code": JPY.code,
"name": JPY.name})
response = self.__client.post(f"{PREFIX}/store",
data={"csrf_token": self.__csrf_token,
"code": JPY.code,
"name": JPY.name})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
add_journal_entry(self.client,
form={"csrf_token": self.csrf_token,
add_journal_entry(self.__client,
form={"csrf_token": self.__csrf_token,
"next": encoded_next_uri,
"date": dt.date.today().isoformat(),
"currency-1-code": EUR.code,
"currency-1-credit-1-account_code": "1111-001",
"currency-1-credit-1-amount": "20"})
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Currency.query.all()},
{USD.code, EUR.code, JPY.code})
# Cannot delete the default currency
response = self.client.post(f"{PREFIX}/{USD.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{USD.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{USD.code}")
# Cannot delete the account that is in use
response = self.client.post(f"{PREFIX}/{EUR.code}/delete",
data={"csrf_token": self.csrf_token})
response = self.__client.post(f"{PREFIX}/{EUR.code}/delete",
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], f"{PREFIX}/{EUR.code}")
# Success
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 200)
response = self.client.post(delete_uri,
data={"csrf_token": self.csrf_token})
response = self.__client.post(delete_uri,
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], list_uri)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual({x.code for x in Currency.query.all()},
{USD.code, EUR.code})
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 404)
response = self.client.post(delete_uri,
data={"csrf_token": self.csrf_token})
response = self.__client.post(delete_uri,
data={"csrf_token": self.__csrf_token})
self.assertEqual(response.status_code, 404)

View File

@ -37,19 +37,19 @@ class DescriptionEditorTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import JournalEntry, JournalEntryLineItem
JournalEntry.query.delete()
JournalEntryLineItem.query.delete()
self.encoded_next_uri: str = encode_next(NEXT_URI)
self.__encoded_next_uri: str = encode_next(NEXT_URI)
"""The encoded next URI."""
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
def test_description_editor(self) -> None:
@ -59,9 +59,9 @@ class DescriptionEditorTestCase(unittest.TestCase):
"""
from accounting.journal_entry.utils.description_editor import \
DescriptionEditor
for form in get_form_data(self.csrf_token, self.encoded_next_uri):
add_journal_entry(self.client, form)
with self.app.app_context():
for form in get_form_data(self.__csrf_token, self.__encoded_next_uri):
add_journal_entry(self.__client, form)
with self.__app.app_context():
editor: DescriptionEditor = DescriptionEditor()
# Debit-General

File diff suppressed because it is too large Load Diff

View File

@ -45,23 +45,23 @@ class OffsetTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import JournalEntry, JournalEntryLineItem
JournalEntry.query.delete()
JournalEntryLineItem.query.delete()
self.encoded_next_uri: str = encode_next(NEXT_URI)
self.__encoded_next_uri: str = encode_next(NEXT_URI)
"""The encoded next URI."""
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
self.data: OffsetTestData = OffsetTestData(self.app, "editor")
self.__data: OffsetTestData = OffsetTestData(self.__app, "editor")
"""The offset test data."""
self.data.populate()
self.__data.populate()
def test_add_receivable_offset(self) -> None:
"""Tests to add the receivable offset.
@ -70,128 +70,128 @@ class OffsetTestCase(unittest.TestCase):
"""
from accounting.models import Account, JournalEntry
create_uri: str = (f"{PREFIX}/create/receipt?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
store_uri: str = f"{PREFIX}/store/receipt"
form: dict[str, str]
old_amount: Decimal
response: httpx.Response
journal_entry_data: JournalEntryData = JournalEntryData(
self.data.l_r_or3d.journal_entry.days, [JournalEntryCurrencyData(
self.__data.l_r_or3d.journal_entry.days, [JournalEntryCurrencyData(
"USD",
[],
[JournalEntryLineItemData(
Accounts.RECEIVABLE,
self.data.l_r_or1d.description, "300",
original_line_item=self.data.l_r_or1d),
self.__data.l_r_or1d.description, "300",
original_line_item=self.__data.l_r_or1d),
JournalEntryLineItemData(
Accounts.RECEIVABLE,
self.data.l_r_or1d.description, "100",
original_line_item=self.data.l_r_or1d),
self.__data.l_r_or1d.description, "100",
original_line_item=self.__data.l_r_or1d),
JournalEntryLineItemData(
Accounts.RECEIVABLE,
self.data.l_r_or3d.description, "100",
original_line_item=self.data.l_r_or3d)])])
self.__data.l_r_or3d.description, "100",
original_line_item=self.__data.l_r_or3d)])])
# Non-existing original line item ID
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] = "9999"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# The same debit or credit
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] \
= str(self.data.l_p_or1c.id)
form["currency-1-credit-1-account_code"] = self.data.l_p_or1c.account
= str(self.__data.l_p_or1c.id)
form["currency-1-credit-1-account_code"] = self.__data.l_p_or1c.account
form["currency-1-credit-1-amount"] = "100"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# The original line item does not need offset
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
account.is_need_offset = False
db.session.commit()
response = self.client.post(
response = self.__client.post(
store_uri,
data=journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri))
data=journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri))
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
account.is_need_offset = True
db.session.commit()
# The original line item is also an offset
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] \
= str(self.data.l_p_of1d.id)
form["currency-1-credit-1-account_code"] = self.data.l_p_of1d.account
response = self.client.post(store_uri, data=form)
= str(self.__data.l_p_of1d.id)
form["currency-1-credit-1-account_code"] = self.__data.l_p_of1d.account
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not the same currency
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not the same account
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-account_code"] = Accounts.NOTES_RECEIVABLE
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not exceeding net balance - partially offset
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-amount"] \
= str(journal_entry_data.currencies[0].credit[0].amount
+ Decimal("0.01"))
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not exceeding net balance - unmatched
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-3-amount"] \
= str(journal_entry_data.currencies[0].credit[2].amount
+ Decimal("0.01"))
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not before the original line items
old_days = journal_entry_data.days
journal_entry_data.days = old_days + 1
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(store_uri, data=form)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
journal_entry_data.days = old_days
# Success
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(store_uri, data=form)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
journal_entry_id: int \
= match_journal_entry_detail(response.headers["Location"])
with self.app.app_context():
with self.__app.app_context():
journal_entry = db.session.get(JournalEntry, journal_entry_id)
for offset in journal_entry.currencies[0].credit:
self.assertIsNotNone(offset.original_line_item_id)
@ -202,125 +202,125 @@ class OffsetTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import Account
journal_entry_data: JournalEntryData = self.data.j_r_of2
journal_entry_data: JournalEntryData = self.__data.j_r_of2
edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update"
form: dict[str, str]
response: httpx.Response
journal_entry_data.days = self.data.j_r_or2.days
journal_entry_data.days = self.__data.j_r_or2.days
journal_entry_data.currencies[0].debit[0].amount = Decimal("600")
journal_entry_data.currencies[0].credit[0].amount = Decimal("600")
journal_entry_data.currencies[0].debit[2].amount = Decimal("600")
journal_entry_data.currencies[0].credit[2].amount = Decimal("600")
# Non-existing original line item ID
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] = "9999"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# The same debit or credit
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] \
= str(self.data.l_p_or1c.id)
form["currency-1-credit-1-account_code"] = self.data.l_p_or1c.account
= str(self.__data.l_p_or1c.id)
form["currency-1-credit-1-account_code"] = self.__data.l_p_or1c.account
form["currency-1-debit-1-amount"] = "100"
form["currency-1-credit-1-amount"] = "100"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# The original line item does not need offset
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
account.is_need_offset = False
db.session.commit()
response = self.client.post(
response = self.__client.post(
update_uri,
data=journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri))
data=journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri))
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
account.is_need_offset = True
db.session.commit()
# The original line item is also an offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-original_line_item_id"] \
= str(self.data.l_p_of1d.id)
form["currency-1-credit-1-account_code"] = self.data.l_p_of1d.account
response = self.client.post(update_uri, data=form)
= str(self.__data.l_p_of1d.id)
form["currency-1-credit-1-account_code"] = self.__data.l_p_of1d.account
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same currency
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same account
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-account_code"] = Accounts.NOTES_RECEIVABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not exceeding net balance - partially offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-amount"] \
= str(journal_entry_data.currencies[0].debit[0].amount
+ Decimal("0.01"))
form["currency-1-credit-1-amount"] \
= str(journal_entry_data.currencies[0].credit[0].amount
+ Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not exceeding net balance - unmatched
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-3-amount"] \
= str(journal_entry_data.currencies[0].debit[2].amount
+ Decimal("0.01"))
form["currency-1-credit-3-amount"] \
= str(journal_entry_data.currencies[0].credit[2].amount
+ Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not before the original line items
old_days: int = journal_entry_data.days
journal_entry_data.days = old_days + 1
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
journal_entry_data.days = old_days
# Success
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{journal_entry_data.id}?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
def test_edit_receivable_original_line_item(self) -> None:
"""Tests to edit the receivable original line item.
@ -328,96 +328,96 @@ class OffsetTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import JournalEntry
journal_entry_data: JournalEntryData = self.data.j_r_or1
journal_entry_data: JournalEntryData = self.__data.j_r_or1
edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update"
form: dict[str, str]
response: httpx.Response
journal_entry_data.days = self.data.j_r_of1.days
journal_entry_data.days = self.__data.j_r_of1.days
journal_entry_data.currencies[0].debit[0].amount = Decimal("800")
journal_entry_data.currencies[0].credit[0].amount = Decimal("800")
journal_entry_data.currencies[0].debit[1].amount = Decimal("3.4")
journal_entry_data.currencies[0].credit[1].amount = Decimal("3.4")
# Not the same currency
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same account
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-account_code"] = Accounts.NOTES_RECEIVABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not less than offset total - partially offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-amount"] \
= str(journal_entry_data.currencies[0].debit[0].amount
- Decimal("0.01"))
form["currency-1-credit-1-amount"] \
= str(journal_entry_data.currencies[0].credit[0].amount
- Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not less than offset total - fully offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-2-amount"] \
= str(journal_entry_data.currencies[0].debit[1].amount
- Decimal("0.01"))
form["currency-1-credit-2-amount"] \
= str(journal_entry_data.currencies[0].credit[1].amount
- Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not after the offset items
old_days: int = journal_entry_data.days
journal_entry_data.days = old_days - 1
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
journal_entry_data.days = old_days
# Not deleting matched original line items
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
del form["currency-1-debit-1-id"]
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Success
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{journal_entry_data.id}?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
# The original line item is always before the offset item, even when
# they happen in the same day.
with self.app.app_context():
with self.__app.app_context():
journal_entry_or: JournalEntry | None = db.session.get(
JournalEntry, journal_entry_data.id)
self.assertIsNotNone(journal_entry_or)
journal_entry_of: JournalEntry | None = db.session.get(
JournalEntry, self.data.j_r_of1.id)
JournalEntry, self.__data.j_r_of1.id)
self.assertIsNotNone(journal_entry_of)
self.assertEqual(journal_entry_or.date, journal_entry_of.date)
self.assertLess(journal_entry_or.no, journal_entry_of.no)
@ -429,127 +429,127 @@ class OffsetTestCase(unittest.TestCase):
"""
from accounting.models import Account, JournalEntry
create_uri: str = (f"{PREFIX}/create/disbursement?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
store_uri: str = f"{PREFIX}/store/disbursement"
form: dict[str, str]
response: httpx.Response
journal_entry_data: JournalEntryData = JournalEntryData(
self.data.l_p_or3c.journal_entry.days, [JournalEntryCurrencyData(
self.__data.l_p_or3c.journal_entry.days, [JournalEntryCurrencyData(
"USD",
[JournalEntryLineItemData(
Accounts.PAYABLE,
self.data.l_p_or1c.description, "500",
original_line_item=self.data.l_p_or1c),
self.__data.l_p_or1c.description, "500",
original_line_item=self.__data.l_p_or1c),
JournalEntryLineItemData(
Accounts.PAYABLE,
self.data.l_p_or1c.description, "300",
original_line_item=self.data.l_p_or1c),
self.__data.l_p_or1c.description, "300",
original_line_item=self.__data.l_p_or1c),
JournalEntryLineItemData(
Accounts.PAYABLE,
self.data.l_p_or3c.description, "120",
original_line_item=self.data.l_p_or3c)],
self.__data.l_p_or3c.description, "120",
original_line_item=self.__data.l_p_or3c)],
[])])
# Non-existing original line item ID
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] = "9999"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# The same debit or credit
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] \
= str(self.data.l_r_or1d.id)
form["currency-1-debit-1-account_code"] = self.data.l_r_or1d.account
= str(self.__data.l_r_or1d.id)
form["currency-1-debit-1-account_code"] = self.__data.l_r_or1d.account
form["currency-1-debit-1-amount"] = "100"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# The original line item does not need offset
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
account.is_need_offset = False
db.session.commit()
response = self.client.post(
response = self.__client.post(
store_uri,
data=journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri))
data=journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri))
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
account.is_need_offset = True
db.session.commit()
# The original line item is also an offset
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] \
= str(self.data.l_r_of1c.id)
form["currency-1-debit-1-account_code"] = self.data.l_r_of1c.account
response = self.client.post(store_uri, data=form)
= str(self.__data.l_r_of1c.id)
form["currency-1-debit-1-account_code"] = self.__data.l_r_of1c.account
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not the same currency
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not the same account
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-account_code"] = Accounts.NOTES_PAYABLE
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not exceeding net balance - partially offset
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-amount"] \
= str(journal_entry_data.currencies[0].debit[0].amount
+ Decimal("0.01"))
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not exceeding net balance - unmatched
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-3-amount"] \
= str(journal_entry_data.currencies[0].debit[2].amount
+ Decimal("0.01"))
response = self.client.post(store_uri, data=form)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
# Not before the original line items
old_days: int = journal_entry_data.days
journal_entry_data.days = old_days + 1
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(store_uri, data=form)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], create_uri)
journal_entry_data.days = old_days
# Success
form = journal_entry_data.new_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(store_uri, data=form)
form = journal_entry_data.new_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(store_uri, data=form)
self.assertEqual(response.status_code, 302)
journal_entry_id: int \
= match_journal_entry_detail(response.headers["Location"])
with self.app.app_context():
with self.__app.app_context():
journal_entry = db.session.get(JournalEntry, journal_entry_id)
for offset in journal_entry.currencies[0].debit:
self.assertIsNotNone(offset.original_line_item_id)
@ -560,125 +560,125 @@ class OffsetTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import Account, JournalEntry
journal_entry_data: JournalEntryData = self.data.j_p_of2
journal_entry_data: JournalEntryData = self.__data.j_p_of2
edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update"
form: dict[str, str]
response: httpx.Response
journal_entry_data.days = self.data.j_p_or2.days
journal_entry_data.days = self.__data.j_p_or2.days
journal_entry_data.currencies[0].debit[0].amount = Decimal("1100")
journal_entry_data.currencies[0].credit[0].amount = Decimal("1100")
journal_entry_data.currencies[0].debit[2].amount = Decimal("900")
journal_entry_data.currencies[0].credit[2].amount = Decimal("900")
# Non-existing original line item ID
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] = "9999"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# The same debit or credit
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] \
= str(self.data.l_r_or1d.id)
form["currency-1-debit-1-account_code"] = self.data.l_r_or1d.account
= str(self.__data.l_r_or1d.id)
form["currency-1-debit-1-account_code"] = self.__data.l_r_or1d.account
form["currency-1-debit-1-amount"] = "100"
form["currency-1-credit-1-amount"] = "100"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# The original line item does not need offset
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
account.is_need_offset = False
db.session.commit()
response = self.client.post(
response = self.__client.post(
update_uri,
data=journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri))
data=journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri))
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
account.is_need_offset = True
db.session.commit()
# The original line item is also an offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-original_line_item_id"] \
= str(self.data.l_r_of1c.id)
form["currency-1-debit-1-account_code"] = self.data.l_r_of1c.account
response = self.client.post(update_uri, data=form)
= str(self.__data.l_r_of1c.id)
form["currency-1-debit-1-account_code"] = self.__data.l_r_of1c.account
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same currency
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same account
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-account_code"] = Accounts.NOTES_PAYABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not exceeding net balance - partially offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-amount"] \
= str(journal_entry_data.currencies[0].debit[0].amount
+ Decimal("0.01"))
form["currency-1-credit-1-amount"] \
= str(journal_entry_data.currencies[0].credit[0].amount
+ Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not exceeding net balance - unmatched
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-3-amount"] \
= str(journal_entry_data.currencies[0].debit[2].amount
+ Decimal("0.01"))
form["currency-1-credit-3-amount"] \
= str(journal_entry_data.currencies[0].credit[2].amount
+ Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not before the original line items
old_days: int = journal_entry_data.days
journal_entry_data.days = old_days + 1
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
journal_entry_data.days = old_days
# Success
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
journal_entry_id: int \
= match_journal_entry_detail(response.headers["Location"])
with self.app.app_context():
with self.__app.app_context():
journal_entry = db.session.get(JournalEntry, journal_entry_id)
for offset in journal_entry.currencies[0].debit:
self.assertIsNotNone(offset.original_line_item_id)
@ -689,96 +689,96 @@ class OffsetTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import JournalEntry
journal_entry_data: JournalEntryData = self.data.j_p_or1
journal_entry_data: JournalEntryData = self.__data.j_p_or1
edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update"
form: dict[str, str]
response: httpx.Response
journal_entry_data.days = self.data.j_p_of1.days
journal_entry_data.days = self.__data.j_p_of1.days
journal_entry_data.currencies[0].debit[0].amount = Decimal("1200")
journal_entry_data.currencies[0].credit[0].amount = Decimal("1200")
journal_entry_data.currencies[0].debit[1].amount = Decimal("0.9")
journal_entry_data.currencies[0].credit[1].amount = Decimal("0.9")
# Not the same currency
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-code"] = "EUR"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not the same account
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-credit-1-account_code"] = Accounts.NOTES_PAYABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not less than offset total - partially offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-1-amount"] \
= str(journal_entry_data.currencies[0].debit[0].amount
- Decimal("0.01"))
form["currency-1-credit-1-amount"] \
= str(journal_entry_data.currencies[0].credit[0].amount
- Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not less than offset total - fully offset
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
form["currency-1-debit-2-amount"] \
= str(journal_entry_data.currencies[0].debit[1].amount
- Decimal("0.01"))
form["currency-1-credit-2-amount"] \
= str(journal_entry_data.currencies[0].credit[1].amount
- Decimal("0.01"))
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not after the offset items
old_days: int = journal_entry_data.days
journal_entry_data.days = old_days - 1
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
journal_entry_data.days = old_days
# Not deleting matched original line items
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
del form["currency-1-credit-1-id"]
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Success
form = journal_entry_data.update_form(self.csrf_token,
self.encoded_next_uri)
response = self.client.post(update_uri, data=form)
form = journal_entry_data.update_form(self.__csrf_token,
self.__encoded_next_uri)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{PREFIX}/{journal_entry_data.id}?"
f"next={self.encoded_next_uri}")
f"next={self.__encoded_next_uri}")
# The original line item is always before the offset item, even when
# they happen in the same day
with self.app.app_context():
with self.__app.app_context():
journal_entry_or: JournalEntry | None = db.session.get(
JournalEntry, journal_entry_data.id)
self.assertIsNotNone(journal_entry_or)
journal_entry_of: JournalEntry | None = db.session.get(
JournalEntry, self.data.j_p_of1.id)
JournalEntry, self.__data.j_p_of1.id)
self.assertIsNotNone(journal_entry_of)
self.assertEqual(journal_entry_or.date, journal_entry_of.date)
self.assertLess(journal_entry_or.no, journal_entry_of.no)

View File

@ -41,18 +41,18 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import Option
Option.query.delete()
self.encoded_next_uri: str = encode_next(NEXT_URI)
self.__encoded_next_uri: str = encode_next(NEXT_URI)
"""The encoded next URI."""
self.client: httpx.Client = get_client(self.app, "admin")
self.__client: httpx.Client = get_client(self.__app, "admin")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
def test_nobody(self) -> None:
@ -60,10 +60,10 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "nobody")
client: httpx.Client = get_client(self.__app, "nobody")
csrf_token: str = get_csrf_token(client)
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
response: httpx.Response
@ -81,10 +81,10 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "viewer")
client: httpx.Client = get_client(self.__app, "viewer")
csrf_token: str = get_csrf_token(client)
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
response: httpx.Response
@ -102,10 +102,10 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "editor")
client: httpx.Client = get_client(self.__app, "editor")
csrf_token: str = get_csrf_token(client)
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
response: httpx.Response
@ -123,18 +123,18 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
response: httpx.Response
response = self.client.get(detail_uri)
response = self.__client.get(detail_uri)
self.assertEqual(response.status_code, 200)
response = self.client.get(edit_uri)
response = self.__client.get(edit_uri)
self.assertEqual(response.status_code, 200)
response = self.client.post(update_uri, data=self.__get_form())
response = self.__client.post(update_uri, data=self.__get_form())
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
@ -144,8 +144,8 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
from accounting.utils.options import options
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
form: dict[str, str]
response: httpx.Response
@ -153,35 +153,35 @@ class OptionTestCase(unittest.TestCase):
# Empty currency code
form = self.__get_form()
form["default_currency_code"] = " "
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Non-existing currency code
form = self.__get_form()
form["default_currency_code"] = "ZZZ"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Empty current account
form = self.__get_form()
form["default_ie_account_code"] = " "
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Non-existing current account
form = self.__get_form()
form["default_ie_account_code"] = "9999-999"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Not a current account
form = self.__get_form()
form["default_ie_account_code"] = Accounts.MEAL
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -189,7 +189,7 @@ class OptionTestCase(unittest.TestCase):
form = self.__get_form()
key = [x for x in form if x.endswith("-name")][0]
form[key] = " "
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -197,7 +197,7 @@ class OptionTestCase(unittest.TestCase):
form = self.__get_form()
key = [x for x in form if x.endswith("-account_code")][0]
form[key] = " "
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -207,7 +207,7 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-expense-")
and x.endswith("-account_code")][0]
form[key] = Accounts.SERVICE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -217,7 +217,7 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-income-")
and x.endswith("-account_code")][0]
form[key] = Accounts.UTILITIES
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -227,7 +227,7 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-expense-")
and x.endswith("-account_code")][0]
form[key] = Accounts.PAYABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -237,7 +237,7 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-income-")
and x.endswith("-account_code")][0]
form[key] = Accounts.RECEIVABLE
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
@ -245,22 +245,22 @@ class OptionTestCase(unittest.TestCase):
form = self.__get_form()
key = [x for x in form if x.endswith("-description_template")][0]
form[key] = " "
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], edit_uri)
# Success, with malformed order
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(options.default_currency_code, "USD")
self.assertEqual(options.default_ie_account_code, "1111-001")
self.assertEqual(len(options.recurring.expenses), 0)
self.assertEqual(len(options.recurring.incomes), 0)
response = self.client.post(update_uri, data=self.__get_form())
response = self.__client.post(update_uri, data=self.__get_form())
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(options.default_currency_code, "EUR")
self.assertEqual(options.default_ie_account_code, "0000-000")
self.assertEqual(len(options.recurring.expenses), 4)
@ -281,11 +281,11 @@ class OptionTestCase(unittest.TestCase):
# Success, with no recurring data
form = self.__get_form()
form = {x: form[x] for x in form if not x.startswith("recurring-")}
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
self.assertEqual(len(options.recurring.expenses), 0)
self.assertEqual(len(options.recurring.incomes), 0)
@ -295,17 +295,17 @@ class OptionTestCase(unittest.TestCase):
:return: None.
"""
from accounting.models import Option
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
form: dict[str, str]
option: Option | None
resource: httpx.Response
response = self.client.post(update_uri, data=self.__get_form())
response = self.__client.post(update_uri, data=self.__get_form())
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
option = db.session.get(Option, "recurring")
self.assertIsNotNone(option)
timestamp: dt.datetime \
@ -317,11 +317,11 @@ class OptionTestCase(unittest.TestCase):
# The recurring setting was not modified
form = self.__get_form()
form["default_currency_code"] = "JPY"
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
option = db.session.get(Option, "recurring")
self.assertIsNotNone(option)
self.assertEqual(option.created_at, timestamp)
@ -333,11 +333,11 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-expense-")
and x.endswith("-account_code")][0]
form[key] = Accounts.MEAL
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
option = db.session.get(Option, "recurring")
self.assertIsNotNone(option)
self.assertLess(option.created_at, option.updated_at)
@ -350,16 +350,16 @@ class OptionTestCase(unittest.TestCase):
from accounting.models import Option
from accounting.utils.user import get_user_pk
admin_username, editor_username = "admin", "editor"
detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}"
detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}"
update_uri: str = f"{PREFIX}/update"
option: Option | None
response: httpx.Response
response = self.client.post(update_uri, data=self.__get_form())
response = self.__client.post(update_uri, data=self.__get_form())
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
editor_pk: int = get_user_pk(editor_username)
option = db.session.get(Option, "recurring")
self.assertIsNotNone(option)
@ -372,11 +372,11 @@ class OptionTestCase(unittest.TestCase):
if x.startswith("recurring-expense-")
and x.endswith("-account_code")][0]
form[key] = Accounts.MEAL
response = self.client.post(update_uri, data=form)
response = self.__client.post(update_uri, data=form)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], detail_uri)
with self.app.app_context():
with self.__app.app_context():
option = db.session.get(Option, "recurring")
self.assertIsNotNone(option)
self.assertEqual(option.created_by.username, editor_username)
@ -389,9 +389,9 @@ class OptionTestCase(unittest.TestCase):
:return: The option form.
"""
if csrf_token is None:
csrf_token = self.csrf_token
csrf_token = self.__csrf_token
return {"csrf_token": csrf_token,
"next": self.encoded_next_uri,
"next": self.__encoded_next_uri,
"default_currency_code": "EUR",
"default_ie_account_code": "0000-000",
"recurring-expense-1-name": "Water bill",

View File

@ -41,17 +41,17 @@ class ReportTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import JournalEntry, JournalEntryLineItem
JournalEntry.query.delete()
JournalEntryLineItem.query.delete()
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
def test_nobody(self) -> None:
@ -59,8 +59,8 @@ class ReportTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "nobody")
ReportTestData(self.app, "editor").populate()
client: httpx.Client = get_client(self.__app, "nobody")
ReportTestData(self.__app, "editor").populate()
response: httpx.Response
response = client.get(PREFIX)
@ -150,8 +150,8 @@ class ReportTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "viewer")
ReportTestData(self.app, "editor").populate()
client: httpx.Client = get_client(self.__app, "viewer")
ReportTestData(self.__app, "editor").populate()
response: httpx.Response
response = client.get(PREFIX)
@ -252,101 +252,101 @@ class ReportTestCase(unittest.TestCase):
:return: None.
"""
ReportTestData(self.app, "editor").populate()
ReportTestData(self.__app, "editor").populate()
response: httpx.Response
response = self.client.get(PREFIX)
response = self.__client.get(PREFIX)
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}?as=csv")
response = self.__client.get(f"{PREFIX}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/journal")
response = self.__client.get(f"{PREFIX}/journal")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/journal?as=csv")
response = self.__client.get(f"{PREFIX}/journal?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/ledger")
response = self.__client.get(f"{PREFIX}/ledger")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/ledger?as=csv")
response = self.__client.get(f"{PREFIX}/ledger?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/income-expenses")
response = self.__client.get(f"{PREFIX}/income-expenses")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/income-expenses?as=csv")
response = self.__client.get(f"{PREFIX}/income-expenses?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/trial-balance")
response = self.__client.get(f"{PREFIX}/trial-balance")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/trial-balance?as=csv")
response = self.__client.get(f"{PREFIX}/trial-balance?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/income-statement")
response = self.__client.get(f"{PREFIX}/income-statement")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/income-statement?as=csv")
response = self.__client.get(f"{PREFIX}/income-statement?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/balance-sheet")
response = self.__client.get(f"{PREFIX}/balance-sheet")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/balance-sheet?as=csv")
response = self.__client.get(f"{PREFIX}/balance-sheet?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/unapplied")
response = self.__client.get(f"{PREFIX}/unapplied")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/unapplied?as=csv")
response = self.__client.get(f"{PREFIX}/unapplied?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}")
self.assertEqual(response.status_code, 200)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/unmatched")
response = self.__client.get(f"{PREFIX}/unmatched")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/unmatched?as=csv")
response = self.__client.get(f"{PREFIX}/unmatched?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}")
self.assertEqual(response.status_code, 200)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/search?q=Salary")
response = self.__client.get(f"{PREFIX}/search?q=Salary")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/search?q=Salary&as=csv")
response = self.__client.get(f"{PREFIX}/search?q=Salary&as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/search?q=薪水")
response = self.__client.get(f"{PREFIX}/search?q=薪水")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/search?q=薪水&as=csv")
response = self.__client.get(f"{PREFIX}/search?q=薪水&as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
@ -357,91 +357,91 @@ class ReportTestCase(unittest.TestCase):
"""
response: httpx.Response
response = self.client.get(PREFIX)
response = self.__client.get(PREFIX)
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}?as=csv")
response = self.__client.get(f"{PREFIX}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/journal")
response = self.__client.get(f"{PREFIX}/journal")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/journal?as=csv")
response = self.__client.get(f"{PREFIX}/journal?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/ledger")
response = self.__client.get(f"{PREFIX}/ledger")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/ledger?as=csv")
response = self.__client.get(f"{PREFIX}/ledger?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/income-expenses")
response = self.__client.get(f"{PREFIX}/income-expenses")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/income-expenses?as=csv")
response = self.__client.get(f"{PREFIX}/income-expenses?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/trial-balance")
response = self.__client.get(f"{PREFIX}/trial-balance")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/trial-balance?as=csv")
response = self.__client.get(f"{PREFIX}/trial-balance?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/income-statement")
response = self.__client.get(f"{PREFIX}/income-statement")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/income-statement?as=csv")
response = self.__client.get(f"{PREFIX}/income-statement?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/balance-sheet")
response = self.__client.get(f"{PREFIX}/balance-sheet")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/balance-sheet?as=csv")
response = self.__client.get(f"{PREFIX}/balance-sheet?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/unapplied")
response = self.__client.get(f"{PREFIX}/unapplied")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/unapplied?as=csv")
response = self.__client.get(f"{PREFIX}/unapplied?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}")
self.assertEqual(response.status_code, 200)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/unmatched")
response = self.__client.get(f"{PREFIX}/unmatched")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/unmatched?as=csv")
response = self.__client.get(f"{PREFIX}/unmatched?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}")
self.assertEqual(response.status_code, 200)
response = self.client.get(
response = self.__client.get(
f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}?as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)
response = self.client.get(f"{PREFIX}/search?q=Salary")
response = self.__client.get(f"{PREFIX}/search?q=Salary")
self.assertEqual(response.status_code, 200)
response = self.client.get(f"{PREFIX}/search?q=Salary&as=csv")
response = self.__client.get(f"{PREFIX}/search?q=Salary&as=csv")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Content-Type"], CSV_MIME)

View File

@ -42,19 +42,19 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
with self.app.app_context():
with self.__app.app_context():
from accounting.models import JournalEntry, JournalEntryLineItem
JournalEntry.query.delete()
JournalEntryLineItem.query.delete()
self.encoded_next_uri: str = encode_next(NEXT_URI)
self.__encoded_next_uri: str = encode_next(NEXT_URI)
"""The encoded next URI."""
self.client: httpx.Client = get_client(self.app, "editor")
self.__client: httpx.Client = get_client(self.__app, "editor")
"""The user client."""
self.csrf_token: str = get_csrf_token(self.client)
self.__csrf_token: str = get_csrf_token(self.__client)
"""The CSRF token."""
def test_nobody(self) -> None:
@ -62,14 +62,14 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "nobody")
client: httpx.Client = get_client(self.__app, "nobody")
csrf_token: str = get_csrf_token(client)
DifferentTestData(self.app, "nobody").populate()
DifferentTestData(self.__app, "nobody").populate()
response: httpx.Response
response = client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": csrf_token,
"next": self.encoded_next_uri})
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 403)
def test_viewer(self) -> None:
@ -77,14 +77,14 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
:return: None.
"""
client: httpx.Client = get_client(self.app, "viewer")
client: httpx.Client = get_client(self.__app, "viewer")
csrf_token: str = get_csrf_token(client)
DifferentTestData(self.app, "viewer").populate()
DifferentTestData(self.__app, "viewer").populate()
response: httpx.Response
response = client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": csrf_token,
"next": self.encoded_next_uri})
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 403)
def test_editor(self) -> None:
@ -92,12 +92,12 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
:return: None.
"""
DifferentTestData(self.app, "editor").populate()
DifferentTestData(self.__app, "editor").populate()
response: httpx.Response
response = self.client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
@ -108,9 +108,9 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
"""
response: httpx.Response
response = self.client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(f"{PREFIX}/{Accounts.PAYABLE}",
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
@ -122,7 +122,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
from accounting.models import Currency, Account, JournalEntryLineItem
from accounting.report.utils.offset_matcher import OffsetMatcher
from accounting.template_globals import default_currency_code
data: DifferentTestData = DifferentTestData(self.app, "editor")
data: DifferentTestData = DifferentTestData(self.__app, "editor")
data.populate()
account: Account | None
line_item: JournalEntryLineItem | None
@ -130,13 +130,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
match_uri: str
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
currency: Currency | None \
= db.session.get(Currency, default_currency_code())
assert currency is not None
# The receivables
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -158,13 +158,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertIsNone(line_item.original_line_item_id)
match_uri = f"{PREFIX}/{Accounts.RECEIVABLE}"
response = self.client.post(match_uri,
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(match_uri,
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -186,7 +186,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertEqual(line_item.original_line_item_id, data.l_r_or4d.id)
# The payables
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -208,13 +208,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertIsNone(line_item.original_line_item_id)
match_uri = f"{PREFIX}/{Accounts.PAYABLE}"
response = self.client.post(match_uri,
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(match_uri,
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -243,7 +243,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
from accounting.models import Currency, Account, JournalEntryLineItem
from accounting.report.utils.offset_matcher import OffsetMatcher
from accounting.template_globals import default_currency_code
data: SameTestData = SameTestData(self.app, "editor")
data: SameTestData = SameTestData(self.__app, "editor")
data.populate()
account: Account | None
line_item: JournalEntryLineItem | None
@ -251,13 +251,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
match_uri: str
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
currency: Currency | None \
= db.session.get(Currency, default_currency_code())
assert currency is not None
# The receivables
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -286,13 +286,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertEqual(line_item.original_line_item_id, data.l_r_or2d.id)
match_uri = f"{PREFIX}/{Accounts.RECEIVABLE}"
response = self.client.post(match_uri,
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(match_uri,
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.RECEIVABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -323,7 +323,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertEqual(line_item.original_line_item_id, data.l_r_or4d.id)
# The payables
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)
@ -352,13 +352,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
self.assertEqual(line_item.original_line_item_id, data.l_p_or2c.id)
match_uri = f"{PREFIX}/{Accounts.PAYABLE}"
response = self.client.post(match_uri,
data={"csrf_token": self.csrf_token,
"next": self.encoded_next_uri})
response = self.__client.post(match_uri,
data={"csrf_token": self.__csrf_token,
"next": self.__encoded_next_uri})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"], NEXT_URI)
with self.app.app_context():
with self.__app.app_context():
account = Account.find_by_code(Accounts.PAYABLE)
assert account is not None
matcher = OffsetMatcher(currency, account)

View File

@ -40,7 +40,7 @@ class NextUriTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
def test_next_uri(self) -> None:
@ -52,7 +52,7 @@ class NextUriTestCase(unittest.TestCase):
"""The test view with the next URI."""
current_uri: str = request.full_path if request.query_string \
else request.path
with self.app.app_context():
with self.__app.app_context():
encoded_current: str = encode_next(current_uri)
self.assertEqual(append_next(self.TARGET),
f"{self.TARGET}?next={encoded_current}")
@ -60,19 +60,20 @@ class NextUriTestCase(unittest.TestCase):
if request.method == "POST" else request.args["next"]
self.assertEqual(inherit_next(self.TARGET),
f"{self.TARGET}?next={encoded_next_uri}")
with self.app.app_context():
with self.__app.app_context():
next_uri: str = decode_next(encoded_next_uri)
self.assertEqual(or_next(self.TARGET), next_uri)
return ""
self.app.add_url_rule("/test-next", view_func=test_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER)
self.__app.add_url_rule("/test-next", view_func=test_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.__app,
base_url=TEST_SERVER)
client.headers["Referer"] = TEST_SERVER
csrf_token: str = get_csrf_token(client)
response: httpx.Response
with self.app.app_context():
with self.__app.app_context():
encoded_uri: str = encode_next(NEXT_URI)
response = client.get(f"/test-next?next={encoded_uri}&q=abc&page-no=4")
self.assertEqual(response.status_code, 200)
@ -92,9 +93,11 @@ class NextUriTestCase(unittest.TestCase):
self.assertEqual(or_next(self.TARGET), self.TARGET)
return ""
self.app.add_url_rule("/test-no-next", view_func=test_no_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER)
self.__app.add_url_rule("/test-no-next",
view_func=test_no_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.__app,
base_url=TEST_SERVER)
client.headers["Referer"] = TEST_SERVER
csrf_token: str = get_csrf_token(client)
response: httpx.Response
@ -116,10 +119,11 @@ class NextUriTestCase(unittest.TestCase):
self.assertEqual(or_next(self.TARGET), self.TARGET)
return ""
self.app.add_url_rule("/test-invalid-next",
view_func=test_invalid_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER)
self.__app.add_url_rule("/test-invalid-next",
view_func=test_invalid_next_uri_view,
methods=["GET", "POST"])
client: httpx.Client = httpx.Client(app=self.__app,
base_url=TEST_SERVER)
client.headers["Referer"] = TEST_SERVER
csrf_token: str = get_csrf_token(client)
next_uri: str
@ -204,28 +208,29 @@ class PaginationTestCase(unittest.TestCase):
:return: None.
"""
self.app: Flask = create_test_app()
self.__app: Flask = create_test_app()
"""The Flask application."""
self.params: PaginationTestCase.Params = self.Params([], None, [], True)
self.__params: PaginationTestCase.Params \
= self.Params([], None, [], True)
"""The testing pagination parameters."""
@self.app.get("/test-pagination")
@self.__app.get("/test-pagination")
def test_pagination_view() -> str:
"""The test view with the pagination."""
pagination: Pagination
if self.params.is_reversed is not None:
if self.__params.is_reversed is not None:
pagination = Pagination[int](
self.params.items, is_reversed=self.params.is_reversed)
self.__params.items, is_reversed=self.__params.is_reversed)
else:
pagination = Pagination[int](self.params.items)
self.assertEqual(pagination.is_paged, self.params.is_paged)
self.assertEqual(pagination.list, self.params.result)
pagination = Pagination[int](self.__params.items)
self.assertEqual(pagination.is_paged, self.__params.is_paged)
self.assertEqual(pagination.list, self.__params.result)
return ""
self.client: httpx.Client = httpx.Client(app=self.app,
base_url=TEST_SERVER)
self.__client: httpx.Client = httpx.Client(app=self.__app,
base_url=TEST_SERVER)
"""The user client."""
self.client.headers["Referer"] = TEST_SERVER
self.__client.headers["Referer"] = TEST_SERVER
def __test_success(self, query: str, items: range,
result: range, is_paged: bool = True,
@ -242,9 +247,9 @@ class PaginationTestCase(unittest.TestCase):
target: str = "/test-pagination"
if query != "":
target = f"{target}?{query}"
self.params = self.Params(list(items), is_reversed,
list(result), is_paged)
response: httpx.Response = self.client.get(target)
self.__params = self.Params(list(items), is_reversed,
list(result), is_paged)
response: httpx.Response = self.__client.get(target)
self.assertEqual(response.status_code, 200)
def __test_malformed(self, query: str, items: range, redirect_to: str,
@ -258,8 +263,8 @@ class PaginationTestCase(unittest.TestCase):
:return: None.
"""
target: str = "/test-pagination"
self.params = self.Params(list(items), is_reversed, [], True)
response: httpx.Response = self.client.get(f"{target}?{query}")
self.__params = self.Params(list(items), is_reversed, [], True)
response: httpx.Response = self.__client.get(f"{target}?{query}")
self.assertEqual(response.status_code, 302)
self.assertEqual(response.headers["Location"],
f"{target}?{redirect_to}")