imacat/mia-accounting
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 41 Wiki Activity

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

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

395
tests/test_account.py
View File

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

8
tests/test_base_account.py
View File

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

14
tests/test_commands.py
View File

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

291
tests/test_currency.py
View File

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

16
tests/test_description_editor.py
View File

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

570
tests/test_journal_entry.py
View File

File diff suppressed because it is too large Load Diff

462
tests/test_offset.py
View File

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

104
tests/test_option.py
View File

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

118
tests/test_report.py
View File

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

84
tests/test_unmatched_offset.py
View File

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

65
tests/test_utils.py
View File

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