From 17acf5efd741e429c4388d6bc5d42f41ddf3ce8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BE=9D=E7=91=AA=E8=B2=93?= Date: Sat, 10 Jun 2023 10:23:33 +0800 Subject: [PATCH] Changed the properties of the test cases from public to private. --- tests/test_account.py | 395 ++++++++++----------- tests/test_base_account.py | 8 +- tests/test_commands.py | 14 +- tests/test_currency.py | 291 ++++++++-------- tests/test_description_editor.py | 16 +- tests/test_journal_entry.py | 570 ++++++++++++++++--------------- tests/test_offset.py | 462 ++++++++++++------------- tests/test_option.py | 104 +++--- tests/test_report.py | 118 +++---- tests/test_unmatched_offset.py | 84 ++--- tests/test_utils.py | 65 ++-- 11 files changed, 1069 insertions(+), 1058 deletions(-) diff --git a/tests/test_account.py b/tests/test_account.py index ed01103..14174cf 100644 --- a/tests/test_account.py +++ b/tests/test_account.py @@ -72,35 +72,35 @@ class AccountTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import Account, AccountL10n AccountL10n.query.delete() Account.query.delete() db.session.commit() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" response: httpx.Response - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": CASH.title}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": CASH.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{CASH.code}") - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": BANK.base_code, - "title": BANK.title}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": BANK.base_code, + "title": BANK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{BANK.code}") @@ -111,7 +111,7 @@ class AccountTestCase(unittest.TestCase): :return: None. """ from accounting.models import Account - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) response: httpx.Response @@ -146,12 +146,12 @@ class AccountTestCase(unittest.TestCase): response = client.get(f"{PREFIX}/bases/{CASH.base_code}") self.assertEqual(response.status_code, 403) - with self.app.app_context(): + with self.__app.app_context(): cash_id: int = Account.find_by_code(CASH.code).id response = client.post(f"{PREFIX}/bases/{CASH.base_code}", data={"csrf_token": csrf_token, - "next": self.encoded_next_uri, + "next": self.__encoded_next_uri, f"{cash_id}-no": "5"}) self.assertEqual(response.status_code, 403) @@ -161,7 +161,7 @@ class AccountTestCase(unittest.TestCase): :return: None. """ from accounting.models import Account - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) response: httpx.Response @@ -196,12 +196,12 @@ class AccountTestCase(unittest.TestCase): response = client.get(f"{PREFIX}/bases/{CASH.base_code}") self.assertEqual(response.status_code, 200) - with self.app.app_context(): + with self.__app.app_context(): cash_id: int = Account.find_by_code(CASH.code).id response = client.post(f"{PREFIX}/bases/{CASH.base_code}", data={"csrf_token": csrf_token, - "next": self.encoded_next_uri, + "next": self.__encoded_next_uri, f"{cash_id}-no": "5"}) self.assertEqual(response.status_code, 403) @@ -213,48 +213,48 @@ class AccountTestCase(unittest.TestCase): from accounting.models import Account response: httpx.Response - response = self.client.get(PREFIX) + response = self.__client.get(PREFIX) self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/{CASH.code}") + response = self.__client.get(f"{PREFIX}/{CASH.code}") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/create") + response = self.__client.get(f"{PREFIX}/create") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{STOCK.code}") - response = self.client.get(f"{PREFIX}/{CASH.code}/edit") + response = self.__client.get(f"{PREFIX}/{CASH.code}/edit") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/{CASH.code}/update", - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": f"{CASH.title}-2"}) + response = self.__client.post(f"{PREFIX}/{CASH.code}/update", + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": f"{CASH.title}-2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{CASH.code}") - response = self.client.post(f"{PREFIX}/{BANK.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{BANK.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], PREFIX) - response = self.client.get(f"{PREFIX}/bases/{CASH.base_code}") + response = self.__client.get(f"{PREFIX}/bases/{CASH.base_code}") self.assertEqual(response.status_code, 200) - with self.app.app_context(): + with self.__app.app_context(): cash_id: int = Account.find_by_code(CASH.code).id - response = self.client.post(f"{PREFIX}/bases/{CASH.base_code}", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, - f"{cash_id}-no": "5"}) + response = self.__client.post(f"{PREFIX}/bases/{CASH.base_code}", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, + f"{cash_id}-no": "5"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) @@ -269,96 +269,97 @@ class AccountTestCase(unittest.TestCase): detail_uri: str = f"{PREFIX}/{STOCK.code}" response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Account.query.all()}, {CASH.code, BANK.code}) # Missing CSRF token - response = self.client.post(store_uri, - data={"base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 400) # CSRF token mismatch - response = self.client.post(store_uri, - data={"csrf_token": f"{self.csrf_token}-2", - "base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": + f"{self.__csrf_token}-2", + "base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 400) # Empty base account code - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": " ", - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": " ", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Non-existing base account - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": "9999", - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "9999", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Unavailable base account - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": "1", - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "1", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Empty name - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": " "}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": " "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # A nominal account that needs offset - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": "6172", - "title": STOCK.title, - "is_need_offset": "yes"}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "6172", + "title": STOCK.title, + "is_need_offset": "yes"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Success, with spaces to be stripped - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": f" {STOCK.base_code} ", - "title": f" {STOCK.title} "}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": f" {STOCK.base_code} ", + "title": f" {STOCK.title} "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) # Success under the same base - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{STOCK.base_code}-002") # Success under the same base, with order in a mess. - with self.app.app_context(): + with self.__app.app_context(): stock_2: Account = Account.find_by_code(f"{STOCK.base_code}-002") stock_2.no = 66 db.session.commit() - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{STOCK.base_code}-003") - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Account.query.all()}, {CASH.code, BANK.code, STOCK.code, f"{STOCK.base_code}-002", @@ -381,71 +382,71 @@ class AccountTestCase(unittest.TestCase): response: httpx.Response # Success, with spaces to be stripped - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": f" {CASH.base_code} ", - "title": f" {CASH.title}-1 "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": f" {CASH.base_code} ", + "title": f" {CASH.title}-1 "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account: Account = Account.find_by_code(CASH.code) self.assertEqual(account.base_code, CASH.base_code) self.assertEqual(account.title_l10n, f"{CASH.title}-1") # Empty base account code - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": " ", - "title": STOCK.title}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": " ", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Non-existing base account - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": "9999", - "title": STOCK.title}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "9999", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Unavailable base account - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": "1", - "title": STOCK.title}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "1", + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Empty name - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": " "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": " "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # A nominal account that needs offset - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": "6172", - "title": STOCK.title, - "is_need_offset": "yes"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": "6172", + "title": STOCK.title, + "is_need_offset": "yes"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Change the base account - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": STOCK.base_code, - "title": STOCK.title}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": STOCK.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_c_uri) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.get(detail_c_uri) + response = self.__client.get(detail_c_uri) self.assertEqual(response.status_code, 200) def test_update_not_modified(self) -> None: @@ -459,14 +460,14 @@ class AccountTestCase(unittest.TestCase): account: Account response: httpx.Response - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": f" {CASH.base_code} ", - "title": f" {CASH.title} "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": f" {CASH.base_code} ", + "title": f" {CASH.title} "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertIsNotNone(account) account.created_at \ @@ -474,14 +475,14 @@ class AccountTestCase(unittest.TestCase): account.updated_at = account.created_at db.session.commit() - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": STOCK.title}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": STOCK.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertIsNotNone(account) self.assertLess(account.created_at, @@ -494,14 +495,14 @@ class AccountTestCase(unittest.TestCase): """ from accounting.models import Account editor_username, admin_username = "editor", "admin" - client: httpx.Client = get_client(self.app, admin_username) + client: httpx.Client = get_client(self.__app, admin_username) csrf_token: str = get_csrf_token(client) detail_uri: str = f"{PREFIX}/{CASH.code}" update_uri: str = f"{PREFIX}/{CASH.code}/update" account: Account response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.created_by.username, editor_username) self.assertEqual(account.updated_by.username, editor_username) @@ -513,7 +514,7 @@ class AccountTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.created_by.username, editor_username) @@ -531,51 +532,51 @@ class AccountTestCase(unittest.TestCase): account: Account response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.title_l10n, CASH.title) self.assertEqual(account.l10n, []) - set_locale(self.app, self.client, self.csrf_token, "zh_Hant") + set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": f"{CASH.title}-zh_Hant"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": f"{CASH.title}-zh_Hant"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.title_l10n, CASH.title) self.assertEqual({(x.locale, x.title) for x in account.l10n}, {("zh_Hant", f"{CASH.title}-zh_Hant")}) - set_locale(self.app, self.client, self.csrf_token, "en") + set_locale(self.__app, self.__client, self.__csrf_token, "en") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": f"{CASH.title}-2"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": f"{CASH.title}-2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.title_l10n, f"{CASH.title}-2") self.assertEqual({(x.locale, x.title) for x in account.l10n}, {("zh_Hant", f"{CASH.title}-zh_Hant")}) - set_locale(self.app, self.client, self.csrf_token, "zh_Hant") + set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "base_code": CASH.base_code, - "title": f"{CASH.title}-zh_Hant-2"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "base_code": CASH.base_code, + "title": f"{CASH.title}-zh_Hant-2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(CASH.code) self.assertEqual(account.title_l10n, f"{CASH.title}-2") self.assertEqual({(x.locale, x.title) for x in account.l10n}, @@ -592,53 +593,53 @@ class AccountTestCase(unittest.TestCase): list_uri: str = PREFIX response: httpx.Response - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": PETTY.base_code, - "title": PETTY.title}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": PETTY.base_code, + "title": PETTY.title}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - add_journal_entry(self.client, - form={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, + add_journal_entry(self.__client, + form={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, "date": dt.date.today().isoformat(), "currency-1-code": "USD", "currency-1-credit-1-account_code": BANK.code, "currency-1-credit-1-amount": "20"}) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Account.query.all()}, {CASH.code, PETTY.code, BANK.code}) # Cannot delete the cash account - response = self.client.post(f"{PREFIX}/{CASH.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{CASH.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{CASH.code}") # Cannot delete the account that is in use - response = self.client.post(f"{PREFIX}/{BANK.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{BANK.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{BANK.code}") # Success - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], list_uri) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Account.query.all()}, {CASH.code, BANK.code}) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 404) def test_change_base_code(self) -> None: @@ -650,15 +651,15 @@ class AccountTestCase(unittest.TestCase): response: httpx.Response for i in range(2, 6): - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": "1111", - "title": "Title"}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": "1111", + "title": "Title"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/1111-00{i}") - with self.app.app_context(): + with self.__app.app_context(): account_1: Account = Account.find_by_code("1111-001") id_1: int = account_1.id account_2: Account = Account.find_by_code("1111-002") @@ -678,14 +679,14 @@ class AccountTestCase(unittest.TestCase): account_5.no = 6 db.session.commit() - response = self.client.post(f"{PREFIX}/1111-005/update", - data={"csrf_token": self.csrf_token, - "base_code": "1112", - "title": "Title"}) + response = self.__client.post(f"{PREFIX}/1111-005/update", + data={"csrf_token": self.__csrf_token, + "base_code": "1112", + "title": "Title"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/1112-003") - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(Account, id_1).no, 1) self.assertEqual(db.session.get(Account, id_2).no, 3) self.assertEqual(db.session.get(Account, id_3).no, 2) @@ -701,34 +702,34 @@ class AccountTestCase(unittest.TestCase): response: httpx.Response for i in range(2, 6): - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "base_code": "1111", - "title": "Title"}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "base_code": "1111", + "title": "Title"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/1111-00{i}") # Normal reorder - with self.app.app_context(): + with self.__app.app_context(): id_1: int = Account.find_by_code("1111-001").id id_2: int = Account.find_by_code("1111-002").id id_3: int = Account.find_by_code("1111-003").id id_4: int = Account.find_by_code("1111-004").id id_5: int = Account.find_by_code("1111-005").id - response = self.client.post(f"{PREFIX}/bases/1111", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, - f"{id_1}-no": "4", - f"{id_2}-no": "1", - f"{id_3}-no": "5", - f"{id_4}-no": "2", - f"{id_5}-no": "3"}) + response = self.__client.post(f"{PREFIX}/bases/1111", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, + f"{id_1}-no": "4", + f"{id_2}-no": "1", + f"{id_3}-no": "5", + f"{id_4}-no": "2", + f"{id_5}-no": "3"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(Account, id_1).code, "1111-004") self.assertEqual(db.session.get(Account, id_2).code, "1111-001") self.assertEqual(db.session.get(Account, id_3).code, "1111-005") @@ -736,7 +737,7 @@ class AccountTestCase(unittest.TestCase): self.assertEqual(db.session.get(Account, id_5).code, "1111-003") # Malformed orders - with self.app.app_context(): + with self.__app.app_context(): db.session.get(Account, id_1).no = 3 db.session.get(Account, id_2).no = 4 db.session.get(Account, id_3).no = 6 @@ -744,16 +745,16 @@ class AccountTestCase(unittest.TestCase): db.session.get(Account, id_5).no = 9 db.session.commit() - response = self.client.post(f"{PREFIX}/bases/1111", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, - f"{id_2}-no": "3a", - f"{id_3}-no": "5", - f"{id_4}-no": "2"}) + response = self.__client.post(f"{PREFIX}/bases/1111", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, + f"{id_2}-no": "3a", + f"{id_3}-no": "5", + f"{id_4}-no": "2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(Account, id_1).code, "1111-003") self.assertEqual(db.session.get(Account, id_2).code, "1111-004") self.assertEqual(db.session.get(Account, id_3).code, "1111-002") diff --git a/tests/test_base_account.py b/tests/test_base_account.py index 015b66c..e31c7e6 100644 --- a/tests/test_base_account.py +++ b/tests/test_base_account.py @@ -39,7 +39,7 @@ class BaseAccountTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" def test_nobody(self) -> None: @@ -47,7 +47,7 @@ class BaseAccountTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") response: httpx.Response response = client.get(LIST_URI) @@ -61,7 +61,7 @@ class BaseAccountTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") response: httpx.Response response = client.get(LIST_URI) @@ -75,7 +75,7 @@ class BaseAccountTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "editor") + client: httpx.Client = get_client(self.__app, "editor") response: httpx.Response response = client.get(LIST_URI) diff --git a/tests/test_commands.py b/tests/test_commands.py index f786114..c21ad9d 100644 --- a/tests/test_commands.py +++ b/tests/test_commands.py @@ -40,10 +40,10 @@ class ConsoleCommandTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): # Drop every accounting table, to see if accounting-init recreates # them correctly. tables: list[sa.Table] \ @@ -62,8 +62,8 @@ class ConsoleCommandTestCase(unittest.TestCase): :return: None. """ - runner: FlaskCliRunner = self.app.test_cli_runner() - with self.app.app_context(): + runner: FlaskCliRunner = self.__app.test_cli_runner() + with self.__app.app_context(): result: Result = runner.invoke( args=["accounting-init-db", "-u", "editor"]) self.assertEqual(result.exit_code, 0, @@ -88,7 +88,7 @@ class ConsoleCommandTestCase(unittest.TestCase): for y in x if y.startswith("l10n-")}} for x in csv.DictReader(fp)} - with self.app.app_context(): + with self.__app.app_context(): accounts: list[BaseAccount] = BaseAccount.query.all() self.assertEqual(len(accounts), len(data)) @@ -109,7 +109,7 @@ class ConsoleCommandTestCase(unittest.TestCase): """ from accounting.models import BaseAccount, Account, AccountL10n - with self.app.app_context(): + with self.__app.app_context(): bases: list[BaseAccount] = BaseAccount.query\ .filter(sa.func.char_length(BaseAccount.code) == 4).all() accounts: list[Account] = Account.query.all() @@ -143,7 +143,7 @@ class ConsoleCommandTestCase(unittest.TestCase): for y in x if y.startswith("l10n-")}} for x in csv.DictReader(fp)} - with self.app.app_context(): + with self.__app.app_context(): currencies: list[Currency] = Currency.query.all() self.assertEqual(len(currencies), len(data)) diff --git a/tests/test_currency.py b/tests/test_currency.py index d620696..5109a97 100644 --- a/tests/test_currency.py +++ b/tests/test_currency.py @@ -65,32 +65,32 @@ class CurrencyTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import Currency, CurrencyL10n CurrencyL10n.query.delete() Currency.query.delete() db.session.commit() - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" response: httpx.Response - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "code": USD.code, - "name": USD.name}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "code": USD.code, + "name": USD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{USD.code}") - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "code": EUR.code, - "name": EUR.name}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "code": EUR.code, + "name": EUR.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{EUR.code}") @@ -99,7 +99,7 @@ class CurrencyTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) response: httpx.Response @@ -136,7 +136,7 @@ class CurrencyTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) response: httpx.Response @@ -175,34 +175,34 @@ class CurrencyTestCase(unittest.TestCase): """ response: httpx.Response - response = self.client.get(PREFIX) + response = self.__client.get(PREFIX) self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/{USD.code}") + response = self.__client.get(f"{PREFIX}/{USD.code}") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/create") + response = self.__client.get(f"{PREFIX}/create") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "code": TWD.code, - "name": TWD.name}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "code": TWD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{TWD.code}") - response = self.client.get(f"{PREFIX}/{USD.code}/edit") + response = self.__client.get(f"{PREFIX}/{USD.code}/edit") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/{USD.code}/update", - data={"csrf_token": self.csrf_token, - "code": JPY.code, - "name": JPY.name}) + response = self.__client.post(f"{PREFIX}/{USD.code}/update", + data={"csrf_token": self.__csrf_token, + "code": JPY.code, + "name": JPY.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{JPY.code}") - response = self.client.post(f"{PREFIX}/{EUR.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{EUR.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], PREFIX) @@ -217,72 +217,73 @@ class CurrencyTestCase(unittest.TestCase): detail_uri: str = f"{PREFIX}/{TWD.code}" response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Currency.query.all()}, {USD.code, EUR.code}) # Missing CSRF token - response = self.client.post(store_uri, - data={"code": TWD.code, - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"code": TWD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 400) # CSRF token mismatch - response = self.client.post(store_uri, - data={"csrf_token": f"{self.csrf_token}-2", - "code": TWD.code, - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"csrf_token": + f"{self.__csrf_token}-2", + "code": TWD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 400) # Empty code - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": " ", - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": " ", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Blocked code, with spaces to be stripped - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": " create ", - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": " create ", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Bad code - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": " zzc ", - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": " zzc ", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Empty name - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": TWD.code, - "name": " "}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": TWD.code, + "name": " "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Success, with spaces to be stripped - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": f" {TWD.code} ", - "name": f" {TWD.name} "}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": f" {TWD.code} ", + "name": f" {TWD.name} "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) # Duplicated code - response = self.client.post(store_uri, - data={"csrf_token": self.csrf_token, - "code": TWD.code, - "name": TWD.name}) + response = self.__client.post(store_uri, + data={"csrf_token": self.__csrf_token, + "code": TWD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Currency.query.all()}, {USD.code, EUR.code, TWD.code}) @@ -303,70 +304,70 @@ class CurrencyTestCase(unittest.TestCase): response: httpx.Response # Success, with spaces to be stripped - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": f" {USD.code} ", - "name": f" {USD.name}-1 "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": f" {USD.code} ", + "name": f" {USD.name}-1 "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency: Currency = db.session.get(Currency, USD.code) self.assertEqual(currency.code, USD.code) self.assertEqual(currency.name_l10n, f"{USD.name}-1") # Empty code - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": " ", - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": " ", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Blocked code, with spaces to be stripped - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": " create ", - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": " create ", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Bad code - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": "abc/def", - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": "abc/def", + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Empty name - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": TWD.code, - "name": " "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": TWD.code, + "name": " "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Duplicated code - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": EUR.code, - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": EUR.code, + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Change code - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": TWD.code, - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": TWD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_c_uri) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.get(detail_c_uri) + response = self.__client.get(detail_c_uri) self.assertEqual(response.status_code, 200) def test_update_not_modified(self) -> None: @@ -380,14 +381,14 @@ class CurrencyTestCase(unittest.TestCase): currency: Currency | None response: httpx.Response - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": f" {USD.code} ", - "name": f" {USD.name} "}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": f" {USD.code} ", + "name": f" {USD.name} "}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertIsNotNone(currency) currency.created_at \ @@ -395,14 +396,14 @@ class CurrencyTestCase(unittest.TestCase): currency.updated_at = currency.created_at db.session.commit() - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": USD.code, - "name": TWD.name}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": USD.code, + "name": TWD.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertIsNotNone(currency) self.assertLess(currency.created_at, @@ -415,14 +416,14 @@ class CurrencyTestCase(unittest.TestCase): """ from accounting.models import Currency editor_username, admin_username = "editor", "admin" - client: httpx.Client = get_client(self.app, admin_username) + client: httpx.Client = get_client(self.__app, admin_username) csrf_token: str = get_csrf_token(client) detail_uri: str = f"{PREFIX}/{USD.code}" update_uri: str = f"{PREFIX}/{USD.code}/update" currency: Currency response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.created_by.username, editor_username) self.assertEqual(currency.updated_by.username, editor_username) @@ -434,7 +435,7 @@ class CurrencyTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.created_by.username, editor_username) self.assertEqual(currency.updated_by.username, admin_username) @@ -446,14 +447,14 @@ class CurrencyTestCase(unittest.TestCase): """ response: httpx.Response - response = self.client.get( + response = self.__client.get( f"/accounting/api/currencies/exists-code?q={USD.code}") self.assertEqual(response.status_code, 200) data = response.json() self.assertEqual(set(data.keys()), {"exists"}) self.assertTrue(data["exists"]) - response = self.client.get( + response = self.__client.get( f"/accounting/api/currencies/exists-code?q={USD.code}-1") self.assertEqual(response.status_code, 200) data = response.json() @@ -471,51 +472,51 @@ class CurrencyTestCase(unittest.TestCase): currency: Currency response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.name_l10n, USD.name) self.assertEqual(currency.l10n, []) - set_locale(self.app, self.client, self.csrf_token, "zh_Hant") + set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": USD.code, - "name": f"{USD.name}-zh_Hant"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": USD.code, + "name": f"{USD.name}-zh_Hant"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.name_l10n, USD.name) self.assertEqual({(x.locale, x.name) for x in currency.l10n}, {("zh_Hant", f"{USD.name}-zh_Hant")}) - set_locale(self.app, self.client, self.csrf_token, "en") + set_locale(self.__app, self.__client, self.__csrf_token, "en") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": USD.code, - "name": f"{USD.name}-2"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": USD.code, + "name": f"{USD.name}-2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.name_l10n, f"{USD.name}-2") self.assertEqual({(x.locale, x.name) for x in currency.l10n}, {("zh_Hant", f"{USD.name}-zh_Hant")}) - set_locale(self.app, self.client, self.csrf_token, "zh_Hant") + set_locale(self.__app, self.__client, self.__csrf_token, "zh_Hant") - response = self.client.post(update_uri, - data={"csrf_token": self.csrf_token, - "code": USD.code, - "name": f"{USD.name}-zh_Hant-2"}) + response = self.__client.post(update_uri, + data={"csrf_token": self.__csrf_token, + "code": USD.code, + "name": f"{USD.name}-zh_Hant-2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): currency = db.session.get(Currency, USD.code) self.assertEqual(currency.name_l10n, f"{USD.name}-2") self.assertEqual({(x.locale, x.name) for x in currency.l10n}, @@ -529,56 +530,56 @@ class CurrencyTestCase(unittest.TestCase): from accounting.models import Currency detail_uri: str = f"{PREFIX}/{JPY.code}" delete_uri: str = f"{PREFIX}/{JPY.code}/delete" - with self.app.app_context(): + with self.__app.app_context(): encoded_next_uri: str = encode_next(NEXT_URI) list_uri: str = PREFIX response: httpx.Response - response = self.client.post(f"{PREFIX}/store", - data={"csrf_token": self.csrf_token, - "code": JPY.code, - "name": JPY.name}) + response = self.__client.post(f"{PREFIX}/store", + data={"csrf_token": self.__csrf_token, + "code": JPY.code, + "name": JPY.name}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - add_journal_entry(self.client, - form={"csrf_token": self.csrf_token, + add_journal_entry(self.__client, + form={"csrf_token": self.__csrf_token, "next": encoded_next_uri, "date": dt.date.today().isoformat(), "currency-1-code": EUR.code, "currency-1-credit-1-account_code": "1111-001", "currency-1-credit-1-amount": "20"}) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Currency.query.all()}, {USD.code, EUR.code, JPY.code}) # Cannot delete the default currency - response = self.client.post(f"{PREFIX}/{USD.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{USD.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{USD.code}") # Cannot delete the account that is in use - response = self.client.post(f"{PREFIX}/{EUR.code}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{EUR.code}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{EUR.code}") # Success - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], list_uri) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual({x.code for x in Currency.query.all()}, {USD.code, EUR.code}) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 404) diff --git a/tests/test_description_editor.py b/tests/test_description_editor.py index d8408ff..890f284 100644 --- a/tests/test_description_editor.py +++ b/tests/test_description_editor.py @@ -37,19 +37,19 @@ class DescriptionEditorTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_description_editor(self) -> None: @@ -59,9 +59,9 @@ class DescriptionEditorTestCase(unittest.TestCase): """ from accounting.journal_entry.utils.description_editor import \ DescriptionEditor - for form in get_form_data(self.csrf_token, self.encoded_next_uri): - add_journal_entry(self.client, form) - with self.app.app_context(): + for form in get_form_data(self.__csrf_token, self.__encoded_next_uri): + add_journal_entry(self.__client, form) + with self.__app.app_context(): editor: DescriptionEditor = DescriptionEditor() # Debit-General diff --git a/tests/test_journal_entry.py b/tests/test_journal_entry.py index 5eed96e..2d99499 100644 --- a/tests/test_journal_entry.py +++ b/tests/test_journal_entry.py @@ -48,19 +48,19 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -68,9 +68,9 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) - journal_entry_id: int = add_journal_entry(self.client, + journal_entry_id: int = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token @@ -103,9 +103,9 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) - journal_entry_id: int = add_journal_entry(self.client, + journal_entry_id: int = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token @@ -138,35 +138,35 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): :return: None. """ - journal_entry_id: int = add_journal_entry(self.client, + journal_entry_id: int = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() update_form: dict[str, str] = self.__get_update_form(journal_entry_id) response: httpx.Response - response = self.client.get(f"{PREFIX}/{journal_entry_id}") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/create/receipt") + response = self.__client.get(f"{PREFIX}/create/receipt") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/store/receipt", - data=add_form) + response = self.__client.post(f"{PREFIX}/store/receipt", + data=add_form) self.assertEqual(response.status_code, 302) match_journal_entry_detail(response.headers["Location"]) - response = self.client.get(f"{PREFIX}/{journal_entry_id}/edit") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}/edit") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/{journal_entry_id}/update", - data=update_form) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/update", + data=update_form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") - response = self.client.post(f"{PREFIX}/{journal_entry_id}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], RETURN_TO_URI) @@ -177,7 +177,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency 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" response: httpx.Response form: dict[str, str] @@ -186,7 +186,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): # No currency content form = self.__get_add_form() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -194,7 +194,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -202,14 +202,14 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # No credit content in a currency form = self.__get_add_form() remove_credit_in_a_currency(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -217,7 +217,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -226,7 +226,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.OFFICE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -235,25 +235,25 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.RECEIVABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Negative amount form = self.__get_add_form() set_negative_amount(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Success - response = self.client.post(store_uri, - data=self.__get_add_form()) + response = self.__client.post(store_uri, + data=self.__get_add_form()) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies: list[JournalEntryCurrency] = journal_entry.currencies @@ -315,12 +315,12 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): # Success, with empty note form = self.__get_add_form() form["note"] = EMPTY_NOTE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertIsNone(journal_entry.note) @@ -332,15 +332,15 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") edit_uri: str = (f"{PREFIX}/{journal_entry_id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" form_0: dict[str, str] = self.__get_update_form(journal_entry_id) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies0: list[JournalEntryCurrency] = journal_entry.currencies @@ -351,7 +351,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): # No currency content form = form_0.copy() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -359,7 +359,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -367,14 +367,14 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # No credit content in a currency form = form_0.copy() remove_credit_in_a_currency(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -382,7 +382,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): form: dict[str, str] = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -391,7 +391,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.OFFICE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -400,23 +400,23 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.RECEIVABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Negative amount form: dict[str, str] = form_0.copy() set_negative_amount(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success - response = self.client.post(update_uri, data=form_0) + response = self.__client.post(update_uri, data=form_0) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies1: list[JournalEntryCurrency] = journal_entry.currencies @@ -497,20 +497,20 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_unchanged_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) journal_entry.created_at \ @@ -518,12 +518,12 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): journal_entry.updated_at = journal_entry.created_at db.session.commit() - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertLess(journal_entry.created_at, journal_entry.updated_at) @@ -535,17 +535,17 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) editor_username, admin_username = "editor", "admin" - client: httpx.Client = get_client(self.app, admin_username) + client: httpx.Client = get_client(self.__app, admin_username) csrf_token: str = get_csrf_token(client) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -558,7 +558,7 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -572,17 +572,17 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryLineItem journal_entry_id_1: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id_1}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") delete_uri: str = f"{PREFIX}/{journal_entry_id_1}/delete" response: httpx.Response form: dict[str, str] = self.__get_add_form() key: str = [x for x in form if x.endswith("-account_code")][0] form[key] = Accounts.PAYABLE - journal_entry_id_2: int = add_journal_entry(self.client, form) - with self.app.app_context(): + journal_entry_id_2: int = add_journal_entry(self.__client, form) + with self.__app.app_context(): journal_entry: JournalEntry | None \ = db.session.get(JournalEntry, journal_entry_id_2) self.assertIsNotNone(journal_entry) @@ -590,9 +590,9 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): = [x for x in journal_entry.line_items if x.account_code == Accounts.PAYABLE][0] add_journal_entry( - self.client, - form={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, + self.__client, + form={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, "date": dt.date.today().isoformat(), "currency-1-code": line_item.currency_code, "currency-1-debit-1-original_line_item_id": line_item.id, @@ -600,28 +600,28 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): "currency-1-debit-1-amount": "1"}) # Cannot delete the journal entry that is in use - response = self.client.post(f"{PREFIX}/{journal_entry_id_2}/delete", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(f"{PREFIX}/{journal_entry_id_2}/delete", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_id_2}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") # Success - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 404) def __get_add_form(self) -> dict[str, str]: @@ -629,8 +629,8 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): :return: The form data to add a new journal entry. """ - form: dict[str, str] = get_add_form(self.csrf_token, - self.encoded_next_uri) + form: dict[str, str] = get_add_form(self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-debit-" not in x} return form @@ -644,7 +644,8 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): not changed. """ form: dict[str, str] = get_unchanged_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-debit-" not in x} return form @@ -657,8 +658,8 @@ class CashReceiptJournalEntryTestCase(unittest.TestCase): changed. """ form: dict[str, str] = get_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri, - False) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri, False) form = {x: form[x] for x in form if "-debit-" not in x} return form @@ -672,19 +673,19 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -692,10 +693,10 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token update_form: dict[str, str] = self.__get_update_form(journal_entry_id) @@ -727,10 +728,10 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token update_form: dict[str, str] = self.__get_update_form(journal_entry_id) @@ -763,34 +764,34 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: None. """ journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() update_form: dict[str, str] = self.__get_update_form(journal_entry_id) response: httpx.Response - response = self.client.get(f"{PREFIX}/{journal_entry_id}") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/create/disbursement") + response = self.__client.get(f"{PREFIX}/create/disbursement") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/store/disbursement", - data=add_form) + response = self.__client.post(f"{PREFIX}/store/disbursement", + data=add_form) self.assertEqual(response.status_code, 302) match_journal_entry_detail(response.headers["Location"]) - response = self.client.get(f"{PREFIX}/{journal_entry_id}/edit") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}/edit") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/{journal_entry_id}/update", - data=update_form) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/update", + data=update_form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") - response = self.client.post(f"{PREFIX}/{journal_entry_id}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], RETURN_TO_URI) @@ -801,7 +802,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency 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" response: httpx.Response form: dict[str, str] @@ -810,7 +811,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): # No currency content form = self.__get_add_form() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -818,7 +819,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -826,14 +827,14 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # No debit content in a currency form = self.__get_add_form() remove_debit_in_a_currency(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -841,7 +842,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -850,7 +851,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.SERVICE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -859,25 +860,25 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.PAYABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Negative amount form = self.__get_add_form() set_negative_amount(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Success - response = self.client.post(store_uri, - data=self.__get_add_form()) + response = self.__client.post(store_uri, + data=self.__get_add_form()) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies: list[JournalEntryCurrency] = journal_entry.currencies @@ -942,12 +943,12 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): # Success, with empty note form = self.__get_add_form() form["note"] = EMPTY_NOTE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertIsNone(journal_entry.note) @@ -959,15 +960,15 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") edit_uri: str = (f"{PREFIX}/{journal_entry_id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" form_0: dict[str, str] = self.__get_update_form(journal_entry_id) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies0: list[JournalEntryCurrency] = journal_entry.currencies @@ -978,7 +979,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): # No currency content form = form_0.copy() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -986,7 +987,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -994,14 +995,14 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # No debit content in a currency form = form_0.copy() remove_debit_in_a_currency(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1009,7 +1010,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): form: dict[str, str] = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1018,7 +1019,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.SERVICE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1027,23 +1028,23 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.PAYABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Negative amount form: dict[str, str] = form_0.copy() set_negative_amount(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success - response = self.client.post(update_uri, data=form_0) + response = self.__client.post(update_uri, data=form_0) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies1: list[JournalEntryCurrency] = journal_entry.currencies @@ -1128,20 +1129,20 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_unchanged_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) journal_entry.created_at \ @@ -1149,12 +1150,12 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): journal_entry.updated_at = journal_entry.created_at db.session.commit() - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertLess(journal_entry.created_at, journal_entry.updated_at) @@ -1166,17 +1167,17 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) editor_username, admin_username = "editor", "admin" - client: httpx.Client = get_client(self.app, admin_username) + client: httpx.Client = get_client(self.__app, admin_username) csrf_token: str = get_csrf_token(client) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -1189,7 +1190,7 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -1202,25 +1203,25 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: None. """ journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") delete_uri: str = f"{PREFIX}/{journal_entry_id}/delete" response: httpx.Response - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 404) def __get_add_form(self) -> dict[str, str]: @@ -1228,8 +1229,8 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): :return: The form data to add a new journal entry. """ - form: dict[str, str] = get_add_form(self.csrf_token, - self.encoded_next_uri) + form: dict[str, str] = get_add_form(self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-credit-" not in x} return form @@ -1243,7 +1244,8 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): not changed. """ form: dict[str, str] = get_unchanged_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-credit-" not in x} return form @@ -1256,8 +1258,8 @@ class CashDisbursementJournalEntryTestCase(unittest.TestCase): changed. """ form: dict[str, str] = get_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri, - True) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri, True) form = {x: form[x] for x in form if "-credit-" not in x} return form @@ -1271,20 +1273,20 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, \ JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -1292,10 +1294,10 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token update_form: dict[str, str] = self.__get_update_form(journal_entry_id) @@ -1327,10 +1329,10 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() add_form["csrf_token"] = csrf_token update_form: dict[str, str] = self.__get_update_form(journal_entry_id) @@ -1363,34 +1365,34 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: None. """ journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) add_form: dict[str, str] = self.__get_add_form() update_form: dict[str, str] = self.__get_update_form(journal_entry_id) response: httpx.Response - response = self.client.get(f"{PREFIX}/{journal_entry_id}") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/create/transfer") + response = self.__client.get(f"{PREFIX}/create/transfer") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/store/transfer", - data=add_form) + response = self.__client.post(f"{PREFIX}/store/transfer", + data=add_form) self.assertEqual(response.status_code, 302) match_journal_entry_detail(response.headers["Location"]) - response = self.client.get(f"{PREFIX}/{journal_entry_id}/edit") + response = self.__client.get(f"{PREFIX}/{journal_entry_id}/edit") self.assertEqual(response.status_code, 200) - response = self.client.post(f"{PREFIX}/{journal_entry_id}/update", - data=update_form) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/update", + data=update_form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") - response = self.client.post(f"{PREFIX}/{journal_entry_id}/delete", - data={"csrf_token": self.csrf_token}) + response = self.__client.post(f"{PREFIX}/{journal_entry_id}/delete", + data={"csrf_token": self.__csrf_token}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], RETURN_TO_URI) @@ -1401,7 +1403,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency create_uri: str = (f"{PREFIX}/create/transfer?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") store_uri: str = f"{PREFIX}/store/transfer" response: httpx.Response form: dict[str, str] @@ -1410,7 +1412,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): # No currency content form = self.__get_add_form() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1418,7 +1420,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1426,21 +1428,21 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # No debit content in a currency form = self.__get_add_form() remove_debit_in_a_currency(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # No credit content in a currency form = self.__get_add_form() remove_credit_in_a_currency(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1448,7 +1450,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1457,7 +1459,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.SERVICE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1466,7 +1468,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.OFFICE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1475,7 +1477,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.RECEIVABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1484,14 +1486,14 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.PAYABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Negative amount form = self.__get_add_form() set_negative_amount(form) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) @@ -1499,18 +1501,18 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = self.__get_add_form() key: str = [x for x in form.keys() if x.endswith("-amount")][0] form[key] = str(Decimal(form[key]) + 1000) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Success - response = self.client.post(store_uri, - data=self.__get_add_form()) + response = self.__client.post(store_uri, + data=self.__get_add_form()) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies: list[JournalEntryCurrency] = journal_entry.currencies @@ -1578,12 +1580,12 @@ class TransferJournalEntryTestCase(unittest.TestCase): # Success, with empty note form = self.__get_add_form() form["note"] = EMPTY_NOTE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertIsNone(journal_entry.note) @@ -1595,15 +1597,15 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") edit_uri: str = (f"{PREFIX}/{journal_entry_id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" form_0: dict[str, str] = self.__get_update_form(journal_entry_id) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies0: list[JournalEntryCurrency] = journal_entry.currencies @@ -1614,7 +1616,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): # No currency content form = form_0.copy() form = {x: form[x] for x in form if not x.startswith("currency-")} - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1622,7 +1624,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1630,21 +1632,21 @@ class TransferJournalEntryTestCase(unittest.TestCase): form = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-code")][0] form[key] = "ZZZ" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # No debit content in a currency form = form_0.copy() remove_debit_in_a_currency(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # No credit content in a currency form = form_0.copy() remove_credit_in_a_currency(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1652,7 +1654,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): form: dict[str, str] = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-account_code")][0] form[key] = "9999-999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1661,7 +1663,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.SERVICE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1670,7 +1672,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.OFFICE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1679,7 +1681,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-credit-" in x][0] form[key] = Accounts.RECEIVABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1688,14 +1690,14 @@ class TransferJournalEntryTestCase(unittest.TestCase): key: str = [x for x in form.keys() if x.endswith("-account_code") and "-debit-" in x][0] form[key] = Accounts.PAYABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Negative amount form: dict[str, str] = form_0.copy() set_negative_amount(form) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -1703,16 +1705,16 @@ class TransferJournalEntryTestCase(unittest.TestCase): form: dict[str, str] = form_0.copy() key: str = [x for x in form.keys() if x.endswith("-amount")][0] form[key] = str(Decimal(form[key]) + 1000) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success - response = self.client.post(update_uri, data=form_0) + response = self.__client.post(update_uri, data=form_0) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies1: list[JournalEntryCurrency] = journal_entry.currencies @@ -1807,20 +1809,20 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_unchanged_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) journal_entry.created_at \ @@ -1828,12 +1830,12 @@ class TransferJournalEntryTestCase(unittest.TestCase): journal_entry.updated_at = journal_entry.created_at db.session.commit() - response = self.client.post( + response = self.__client.post( update_uri, data=self.__get_update_form(journal_entry_id)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) self.assertLess(journal_entry.created_at, journal_entry.updated_at) @@ -1845,17 +1847,17 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) editor_username, admin_username = "editor", "admin" - client: httpx.Client = get_client(self.app, admin_username) + client: httpx.Client = get_client(self.__app, admin_username) csrf_token: str = get_csrf_token(client) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update" journal_entry: JournalEntry response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -1868,7 +1870,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertEqual(journal_entry.created_by.username, editor_username) @@ -1883,14 +1885,14 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update?as=receipt" form_0: dict[str, str] = self.__get_update_form(journal_entry_id) form_0 = {x: form_0[x] for x in form_0 if "-debit-" not in x} - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies0: list[JournalEntryCurrency] = journal_entry.currencies @@ -1899,11 +1901,11 @@ class TransferJournalEntryTestCase(unittest.TestCase): old_id.update({x.id for x in currency.debit}) # Success - response = self.client.post(update_uri, data=form_0) + response = self.__client.post(update_uri, data=form_0) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies1: list[JournalEntryCurrency] = journal_entry.currencies @@ -1985,14 +1987,14 @@ class TransferJournalEntryTestCase(unittest.TestCase): """ from accounting.models import JournalEntry, JournalEntryCurrency journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_id}/update?as=disbursement" form_0: dict[str, str] = self.__get_update_form(journal_entry_id) form_0 = {x: form_0[x] for x in form_0 if "-credit-" not in x} - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies0: list[JournalEntryCurrency] = journal_entry.currencies @@ -2001,11 +2003,11 @@ class TransferJournalEntryTestCase(unittest.TestCase): old_id.update({x.id for x in currency.debit}) # Success - response = self.client.post(update_uri, data=form_0) + response = self.__client.post(update_uri, data=form_0) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) self.assertIsNotNone(journal_entry) currencies1: list[JournalEntryCurrency] = journal_entry.currencies @@ -2089,25 +2091,25 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: None. """ journal_entry_id: int \ - = add_journal_entry(self.client, self.__get_add_form()) + = add_journal_entry(self.__client, self.__get_add_form()) detail_uri: str = (f"{PREFIX}/{journal_entry_id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") delete_uri: str = f"{PREFIX}/{journal_entry_id}/delete" response: httpx.Response - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 404) - response = self.client.post(delete_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(delete_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 404) def __get_add_form(self) -> dict[str, str]: @@ -2115,7 +2117,7 @@ class TransferJournalEntryTestCase(unittest.TestCase): :return: The form data to add a new journal entry. """ - return get_add_form(self.csrf_token, self.encoded_next_uri) + return get_add_form(self.__csrf_token, self.__encoded_next_uri) def __get_unchanged_update_form(self, journal_entry_id: int) \ -> dict[str, str]: @@ -2127,7 +2129,8 @@ class TransferJournalEntryTestCase(unittest.TestCase): not changed. """ return get_unchanged_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri) def __get_update_form(self, journal_entry_id: int) -> dict[str, str]: """Returns the form data to update a journal entry, where the data are @@ -2138,8 +2141,8 @@ class TransferJournalEntryTestCase(unittest.TestCase): changed. """ return get_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri, - None) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri, None) class JournalEntryReorderTestCase(unittest.TestCase): @@ -2151,19 +2154,19 @@ class JournalEntryReorderTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_change_date(self) -> None: @@ -2174,18 +2177,18 @@ class JournalEntryReorderTestCase(unittest.TestCase): from accounting.models import JournalEntry response: httpx.Response - id_1: int = add_journal_entry(self.client, + id_1: int = add_journal_entry(self.__client, self.__get_add_receipt_form()) - id_2: int = add_journal_entry(self.client, + id_2: int = add_journal_entry(self.__client, self.__get_add_disbursement_form()) - id_3: int = add_journal_entry(self.client, + id_3: int = add_journal_entry(self.__client, self.__get_add_transfer_form()) - id_4: int = add_journal_entry(self.client, + id_4: int = add_journal_entry(self.__client, self.__get_add_receipt_form()) - id_5: int = add_journal_entry(self.client, + id_5: int = add_journal_entry(self.__client, self.__get_add_disbursement_form()) - with self.app.app_context(): + with self.__app.app_context(): journal_entry_1: JournalEntry = db.session.get(JournalEntry, id_1) journal_entry_date_2: dt.date = journal_entry_1.date journal_entry_date_1: dt.date \ @@ -2207,12 +2210,12 @@ class JournalEntryReorderTestCase(unittest.TestCase): form: dict[str, str] \ = self.__get_disbursement_unchanged_update_form(id_2) form["date"] = journal_entry_date_2.isoformat() - response = self.client.post(f"{PREFIX}/{id_2}/update", data=form) + response = self.__client.post(f"{PREFIX}/{id_2}/update", data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], - f"{PREFIX}/{id_2}?next={self.encoded_next_uri}") + f"{PREFIX}/{id_2}?next={self.__encoded_next_uri}") - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(JournalEntry, id_1).no, 1) self.assertEqual(db.session.get(JournalEntry, id_2).no, 3) self.assertEqual(db.session.get(JournalEntry, id_3).no, 2) @@ -2227,24 +2230,24 @@ class JournalEntryReorderTestCase(unittest.TestCase): from accounting.models import JournalEntry response: httpx.Response - id_1: int = add_journal_entry(self.client, + id_1: int = add_journal_entry(self.__client, self.__get_add_receipt_form()) - id_2: int = add_journal_entry(self.client, + id_2: int = add_journal_entry(self.__client, self.__get_add_disbursement_form()) - id_3: int = add_journal_entry(self.client, + id_3: int = add_journal_entry(self.__client, self.__get_add_transfer_form()) - id_4: int = add_journal_entry(self.client, + id_4: int = add_journal_entry(self.__client, self.__get_add_receipt_form()) - id_5: int = add_journal_entry(self.client, + id_5: int = add_journal_entry(self.__client, self.__get_add_disbursement_form()) - with self.app.app_context(): + with self.__app.app_context(): date: dt.date = db.session.get(JournalEntry, id_1).date - response = self.client.post( + response = self.__client.post( f"{PREFIX}/dates/{date.isoformat()}", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, f"{id_1}-no": "4", f"{id_2}-no": "1", f"{id_3}-no": "5", @@ -2253,7 +2256,7 @@ class JournalEntryReorderTestCase(unittest.TestCase): self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(JournalEntry, id_1).no, 4) self.assertEqual(db.session.get(JournalEntry, id_2).no, 1) self.assertEqual(db.session.get(JournalEntry, id_3).no, 5) @@ -2261,7 +2264,7 @@ class JournalEntryReorderTestCase(unittest.TestCase): self.assertEqual(db.session.get(JournalEntry, id_5).no, 3) # Malformed orders - with self.app.app_context(): + with self.__app.app_context(): db.session.get(JournalEntry, id_1).no = 3 db.session.get(JournalEntry, id_2).no = 4 db.session.get(JournalEntry, id_3).no = 6 @@ -2269,17 +2272,17 @@ class JournalEntryReorderTestCase(unittest.TestCase): db.session.get(JournalEntry, id_5).no = 9 db.session.commit() - response = self.client.post( + response = self.__client.post( f"{PREFIX}/dates/{date.isoformat()}", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri, f"{id_2}-no": "3a", f"{id_3}-no": "5", f"{id_4}-no": "2"}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(db.session.get(JournalEntry, id_1).no, 3) self.assertEqual(db.session.get(JournalEntry, id_2).no, 4) self.assertEqual(db.session.get(JournalEntry, id_3).no, 2) @@ -2291,8 +2294,8 @@ class JournalEntryReorderTestCase(unittest.TestCase): :return: The form data to add a new cash receipt journal entry. """ - form: dict[str, str] = get_add_form(self.csrf_token, - self.encoded_next_uri) + form: dict[str, str] = get_add_form(self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-debit-" not in x} return form @@ -2301,8 +2304,8 @@ class JournalEntryReorderTestCase(unittest.TestCase): :return: The form data to add a new cash disbursement journal entry. """ - form: dict[str, str] = get_add_form(self.csrf_token, - self.encoded_next_uri) + form: dict[str, str] = get_add_form(self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-credit-" not in x} return form @@ -2316,7 +2319,8 @@ class JournalEntryReorderTestCase(unittest.TestCase): where the data are not changed. """ form: dict[str, str] = get_unchanged_update_form( - journal_entry_id, self.app, self.csrf_token, self.encoded_next_uri) + journal_entry_id, self.__app, self.__csrf_token, + self.__encoded_next_uri) form = {x: form[x] for x in form if "-credit-" not in x} return form @@ -2325,4 +2329,4 @@ class JournalEntryReorderTestCase(unittest.TestCase): :return: The form data to add a new journal entry. """ - return get_add_form(self.csrf_token, self.encoded_next_uri) + return get_add_form(self.__csrf_token, self.__encoded_next_uri) diff --git a/tests/test_offset.py b/tests/test_offset.py index 192258e..1d36471 100644 --- a/tests/test_offset.py +++ b/tests/test_offset.py @@ -45,23 +45,23 @@ class OffsetTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" - self.data: OffsetTestData = OffsetTestData(self.app, "editor") + self.__data: OffsetTestData = OffsetTestData(self.__app, "editor") """The offset test data.""" - self.data.populate() + self.__data.populate() def test_add_receivable_offset(self) -> None: """Tests to add the receivable offset. @@ -70,128 +70,128 @@ class OffsetTestCase(unittest.TestCase): """ from accounting.models import Account, JournalEntry create_uri: str = (f"{PREFIX}/create/receipt?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") store_uri: str = f"{PREFIX}/store/receipt" form: dict[str, str] old_amount: Decimal response: httpx.Response journal_entry_data: JournalEntryData = JournalEntryData( - self.data.l_r_or3d.journal_entry.days, [JournalEntryCurrencyData( + self.__data.l_r_or3d.journal_entry.days, [JournalEntryCurrencyData( "USD", [], [JournalEntryLineItemData( Accounts.RECEIVABLE, - self.data.l_r_or1d.description, "300", - original_line_item=self.data.l_r_or1d), + self.__data.l_r_or1d.description, "300", + original_line_item=self.__data.l_r_or1d), JournalEntryLineItemData( Accounts.RECEIVABLE, - self.data.l_r_or1d.description, "100", - original_line_item=self.data.l_r_or1d), + self.__data.l_r_or1d.description, "100", + original_line_item=self.__data.l_r_or1d), JournalEntryLineItemData( Accounts.RECEIVABLE, - self.data.l_r_or3d.description, "100", - original_line_item=self.data.l_r_or3d)])]) + self.__data.l_r_or3d.description, "100", + original_line_item=self.__data.l_r_or3d)])]) # Non-existing original line item ID - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] = "9999" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # The same debit or credit - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] \ - = str(self.data.l_p_or1c.id) - form["currency-1-credit-1-account_code"] = self.data.l_p_or1c.account + = str(self.__data.l_p_or1c.id) + form["currency-1-credit-1-account_code"] = self.__data.l_p_or1c.account form["currency-1-credit-1-amount"] = "100" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # The original line item does not need offset - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) account.is_need_offset = False db.session.commit() - response = self.client.post( + response = self.__client.post( store_uri, - data=journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri)) + data=journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) account.is_need_offset = True db.session.commit() # The original line item is also an offset - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] \ - = str(self.data.l_p_of1d.id) - form["currency-1-credit-1-account_code"] = self.data.l_p_of1d.account - response = self.client.post(store_uri, data=form) + = str(self.__data.l_p_of1d.id) + form["currency-1-credit-1-account_code"] = self.__data.l_p_of1d.account + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not the same currency - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not the same account - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-account_code"] = Accounts.NOTES_RECEIVABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not exceeding net balance - partially offset - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-amount"] \ = str(journal_entry_data.currencies[0].credit[0].amount + Decimal("0.01")) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not exceeding net balance - unmatched - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-3-amount"] \ = str(journal_entry_data.currencies[0].credit[2].amount + Decimal("0.01")) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not before the original line items old_days = journal_entry_data.days journal_entry_data.days = old_days + 1 - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(store_uri, data=form) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) journal_entry_data.days = old_days # Success - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(store_uri, data=form) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) for offset in journal_entry.currencies[0].credit: self.assertIsNotNone(offset.original_line_item_id) @@ -202,125 +202,125 @@ class OffsetTestCase(unittest.TestCase): :return: None. """ from accounting.models import Account - journal_entry_data: JournalEntryData = self.data.j_r_of2 + journal_entry_data: JournalEntryData = self.__data.j_r_of2 edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update" form: dict[str, str] response: httpx.Response - journal_entry_data.days = self.data.j_r_or2.days + journal_entry_data.days = self.__data.j_r_or2.days journal_entry_data.currencies[0].debit[0].amount = Decimal("600") journal_entry_data.currencies[0].credit[0].amount = Decimal("600") journal_entry_data.currencies[0].debit[2].amount = Decimal("600") journal_entry_data.currencies[0].credit[2].amount = Decimal("600") # Non-existing original line item ID - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] = "9999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # The same debit or credit - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] \ - = str(self.data.l_p_or1c.id) - form["currency-1-credit-1-account_code"] = self.data.l_p_or1c.account + = str(self.__data.l_p_or1c.id) + form["currency-1-credit-1-account_code"] = self.__data.l_p_or1c.account form["currency-1-debit-1-amount"] = "100" form["currency-1-credit-1-amount"] = "100" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # The original line item does not need offset - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) account.is_need_offset = False db.session.commit() - response = self.client.post( + response = self.__client.post( update_uri, - data=journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri)) + data=journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) account.is_need_offset = True db.session.commit() # The original line item is also an offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-original_line_item_id"] \ - = str(self.data.l_p_of1d.id) - form["currency-1-credit-1-account_code"] = self.data.l_p_of1d.account - response = self.client.post(update_uri, data=form) + = str(self.__data.l_p_of1d.id) + form["currency-1-credit-1-account_code"] = self.__data.l_p_of1d.account + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same currency - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same account - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-account_code"] = Accounts.NOTES_RECEIVABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not exceeding net balance - partially offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-amount"] \ = str(journal_entry_data.currencies[0].debit[0].amount + Decimal("0.01")) form["currency-1-credit-1-amount"] \ = str(journal_entry_data.currencies[0].credit[0].amount + Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not exceeding net balance - unmatched - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-3-amount"] \ = str(journal_entry_data.currencies[0].debit[2].amount + Decimal("0.01")) form["currency-1-credit-3-amount"] \ = str(journal_entry_data.currencies[0].credit[2].amount + Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not before the original line items old_days: int = journal_entry_data.days journal_entry_data.days = old_days + 1 - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) journal_entry_data.days = old_days # Success - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_data.id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") def test_edit_receivable_original_line_item(self) -> None: """Tests to edit the receivable original line item. @@ -328,96 +328,96 @@ class OffsetTestCase(unittest.TestCase): :return: None. """ from accounting.models import JournalEntry - journal_entry_data: JournalEntryData = self.data.j_r_or1 + journal_entry_data: JournalEntryData = self.__data.j_r_or1 edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update" form: dict[str, str] response: httpx.Response - journal_entry_data.days = self.data.j_r_of1.days + journal_entry_data.days = self.__data.j_r_of1.days journal_entry_data.currencies[0].debit[0].amount = Decimal("800") journal_entry_data.currencies[0].credit[0].amount = Decimal("800") journal_entry_data.currencies[0].debit[1].amount = Decimal("3.4") journal_entry_data.currencies[0].credit[1].amount = Decimal("3.4") # Not the same currency - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same account - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-account_code"] = Accounts.NOTES_RECEIVABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not less than offset total - partially offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-amount"] \ = str(journal_entry_data.currencies[0].debit[0].amount - Decimal("0.01")) form["currency-1-credit-1-amount"] \ = str(journal_entry_data.currencies[0].credit[0].amount - Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not less than offset total - fully offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-2-amount"] \ = str(journal_entry_data.currencies[0].debit[1].amount - Decimal("0.01")) form["currency-1-credit-2-amount"] \ = str(journal_entry_data.currencies[0].credit[1].amount - Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not after the offset items old_days: int = journal_entry_data.days journal_entry_data.days = old_days - 1 - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) journal_entry_data.days = old_days # Not deleting matched original line items - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) del form["currency-1-debit-1-id"] - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_data.id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") # The original line item is always before the offset item, even when # they happen in the same day. - with self.app.app_context(): + with self.__app.app_context(): journal_entry_or: JournalEntry | None = db.session.get( JournalEntry, journal_entry_data.id) self.assertIsNotNone(journal_entry_or) journal_entry_of: JournalEntry | None = db.session.get( - JournalEntry, self.data.j_r_of1.id) + JournalEntry, self.__data.j_r_of1.id) self.assertIsNotNone(journal_entry_of) self.assertEqual(journal_entry_or.date, journal_entry_of.date) self.assertLess(journal_entry_or.no, journal_entry_of.no) @@ -429,127 +429,127 @@ class OffsetTestCase(unittest.TestCase): """ from accounting.models import Account, JournalEntry create_uri: str = (f"{PREFIX}/create/disbursement?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") store_uri: str = f"{PREFIX}/store/disbursement" form: dict[str, str] response: httpx.Response journal_entry_data: JournalEntryData = JournalEntryData( - self.data.l_p_or3c.journal_entry.days, [JournalEntryCurrencyData( + self.__data.l_p_or3c.journal_entry.days, [JournalEntryCurrencyData( "USD", [JournalEntryLineItemData( Accounts.PAYABLE, - self.data.l_p_or1c.description, "500", - original_line_item=self.data.l_p_or1c), + self.__data.l_p_or1c.description, "500", + original_line_item=self.__data.l_p_or1c), JournalEntryLineItemData( Accounts.PAYABLE, - self.data.l_p_or1c.description, "300", - original_line_item=self.data.l_p_or1c), + self.__data.l_p_or1c.description, "300", + original_line_item=self.__data.l_p_or1c), JournalEntryLineItemData( Accounts.PAYABLE, - self.data.l_p_or3c.description, "120", - original_line_item=self.data.l_p_or3c)], + self.__data.l_p_or3c.description, "120", + original_line_item=self.__data.l_p_or3c)], [])]) # Non-existing original line item ID - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] = "9999" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # The same debit or credit - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] \ - = str(self.data.l_r_or1d.id) - form["currency-1-debit-1-account_code"] = self.data.l_r_or1d.account + = str(self.__data.l_r_or1d.id) + form["currency-1-debit-1-account_code"] = self.__data.l_r_or1d.account form["currency-1-debit-1-amount"] = "100" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # The original line item does not need offset - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) account.is_need_offset = False db.session.commit() - response = self.client.post( + response = self.__client.post( store_uri, - data=journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri)) + data=journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) account.is_need_offset = True db.session.commit() # The original line item is also an offset - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] \ - = str(self.data.l_r_of1c.id) - form["currency-1-debit-1-account_code"] = self.data.l_r_of1c.account - response = self.client.post(store_uri, data=form) + = str(self.__data.l_r_of1c.id) + form["currency-1-debit-1-account_code"] = self.__data.l_r_of1c.account + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not the same currency - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not the same account - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-account_code"] = Accounts.NOTES_PAYABLE - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not exceeding net balance - partially offset - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-amount"] \ = str(journal_entry_data.currencies[0].debit[0].amount + Decimal("0.01")) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not exceeding net balance - unmatched - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-3-amount"] \ = str(journal_entry_data.currencies[0].debit[2].amount + Decimal("0.01")) - response = self.client.post(store_uri, data=form) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) # Not before the original line items old_days: int = journal_entry_data.days journal_entry_data.days = old_days + 1 - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(store_uri, data=form) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], create_uri) journal_entry_data.days = old_days # Success - form = journal_entry_data.new_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(store_uri, data=form) + form = journal_entry_data.new_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(store_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) for offset in journal_entry.currencies[0].debit: self.assertIsNotNone(offset.original_line_item_id) @@ -560,125 +560,125 @@ class OffsetTestCase(unittest.TestCase): :return: None. """ from accounting.models import Account, JournalEntry - journal_entry_data: JournalEntryData = self.data.j_p_of2 + journal_entry_data: JournalEntryData = self.__data.j_p_of2 edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update" form: dict[str, str] response: httpx.Response - journal_entry_data.days = self.data.j_p_or2.days + journal_entry_data.days = self.__data.j_p_or2.days journal_entry_data.currencies[0].debit[0].amount = Decimal("1100") journal_entry_data.currencies[0].credit[0].amount = Decimal("1100") journal_entry_data.currencies[0].debit[2].amount = Decimal("900") journal_entry_data.currencies[0].credit[2].amount = Decimal("900") # Non-existing original line item ID - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] = "9999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # The same debit or credit - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] \ - = str(self.data.l_r_or1d.id) - form["currency-1-debit-1-account_code"] = self.data.l_r_or1d.account + = str(self.__data.l_r_or1d.id) + form["currency-1-debit-1-account_code"] = self.__data.l_r_or1d.account form["currency-1-debit-1-amount"] = "100" form["currency-1-credit-1-amount"] = "100" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # The original line item does not need offset - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) account.is_need_offset = False db.session.commit() - response = self.client.post( + response = self.__client.post( update_uri, - data=journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri)) + data=journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri)) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) account.is_need_offset = True db.session.commit() # The original line item is also an offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-original_line_item_id"] \ - = str(self.data.l_r_of1c.id) - form["currency-1-debit-1-account_code"] = self.data.l_r_of1c.account - response = self.client.post(update_uri, data=form) + = str(self.__data.l_r_of1c.id) + form["currency-1-debit-1-account_code"] = self.__data.l_r_of1c.account + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same currency - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same account - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-account_code"] = Accounts.NOTES_PAYABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not exceeding net balance - partially offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-amount"] \ = str(journal_entry_data.currencies[0].debit[0].amount + Decimal("0.01")) form["currency-1-credit-1-amount"] \ = str(journal_entry_data.currencies[0].credit[0].amount + Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not exceeding net balance - unmatched - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-3-amount"] \ = str(journal_entry_data.currencies[0].debit[2].amount + Decimal("0.01")) form["currency-1-credit-3-amount"] \ = str(journal_entry_data.currencies[0].credit[2].amount + Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not before the original line items old_days: int = journal_entry_data.days journal_entry_data.days = old_days + 1 - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) journal_entry_data.days = old_days # Success - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) journal_entry_id: int \ = match_journal_entry_detail(response.headers["Location"]) - with self.app.app_context(): + with self.__app.app_context(): journal_entry = db.session.get(JournalEntry, journal_entry_id) for offset in journal_entry.currencies[0].debit: self.assertIsNotNone(offset.original_line_item_id) @@ -689,96 +689,96 @@ class OffsetTestCase(unittest.TestCase): :return: None. """ from accounting.models import JournalEntry - journal_entry_data: JournalEntryData = self.data.j_p_or1 + journal_entry_data: JournalEntryData = self.__data.j_p_or1 edit_uri: str = (f"{PREFIX}/{journal_entry_data.id}/edit?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") update_uri: str = f"{PREFIX}/{journal_entry_data.id}/update" form: dict[str, str] response: httpx.Response - journal_entry_data.days = self.data.j_p_of1.days + journal_entry_data.days = self.__data.j_p_of1.days journal_entry_data.currencies[0].debit[0].amount = Decimal("1200") journal_entry_data.currencies[0].credit[0].amount = Decimal("1200") journal_entry_data.currencies[0].debit[1].amount = Decimal("0.9") journal_entry_data.currencies[0].credit[1].amount = Decimal("0.9") # Not the same currency - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-code"] = "EUR" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not the same account - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-credit-1-account_code"] = Accounts.NOTES_PAYABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not less than offset total - partially offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-1-amount"] \ = str(journal_entry_data.currencies[0].debit[0].amount - Decimal("0.01")) form["currency-1-credit-1-amount"] \ = str(journal_entry_data.currencies[0].credit[0].amount - Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not less than offset total - fully offset - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) form["currency-1-debit-2-amount"] \ = str(journal_entry_data.currencies[0].debit[1].amount - Decimal("0.01")) form["currency-1-credit-2-amount"] \ = str(journal_entry_data.currencies[0].credit[1].amount - Decimal("0.01")) - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not after the offset items old_days: int = journal_entry_data.days journal_entry_data.days = old_days - 1 - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) journal_entry_data.days = old_days # Not deleting matched original line items - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) del form["currency-1-credit-1-id"] - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success - form = journal_entry_data.update_form(self.csrf_token, - self.encoded_next_uri) - response = self.client.post(update_uri, data=form) + form = journal_entry_data.update_form(self.__csrf_token, + self.__encoded_next_uri) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{PREFIX}/{journal_entry_data.id}?" - f"next={self.encoded_next_uri}") + f"next={self.__encoded_next_uri}") # The original line item is always before the offset item, even when # they happen in the same day - with self.app.app_context(): + with self.__app.app_context(): journal_entry_or: JournalEntry | None = db.session.get( JournalEntry, journal_entry_data.id) self.assertIsNotNone(journal_entry_or) journal_entry_of: JournalEntry | None = db.session.get( - JournalEntry, self.data.j_p_of1.id) + JournalEntry, self.__data.j_p_of1.id) self.assertIsNotNone(journal_entry_of) self.assertEqual(journal_entry_or.date, journal_entry_of.date) self.assertLess(journal_entry_or.no, journal_entry_of.no) diff --git a/tests/test_option.py b/tests/test_option.py index 8847473..c3e6e94 100644 --- a/tests/test_option.py +++ b/tests/test_option.py @@ -41,18 +41,18 @@ class OptionTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import Option Option.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "admin") + self.__client: httpx.Client = get_client(self.__app, "admin") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -60,10 +60,10 @@ class OptionTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" - edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" + edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" response: httpx.Response @@ -81,10 +81,10 @@ class OptionTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" - edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" + edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" response: httpx.Response @@ -102,10 +102,10 @@ class OptionTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "editor") + client: httpx.Client = get_client(self.__app, "editor") csrf_token: str = get_csrf_token(client) - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" - edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" + edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" response: httpx.Response @@ -123,18 +123,18 @@ class OptionTestCase(unittest.TestCase): :return: None. """ - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" - edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" + edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" response: httpx.Response - response = self.client.get(detail_uri) + response = self.__client.get(detail_uri) self.assertEqual(response.status_code, 200) - response = self.client.get(edit_uri) + response = self.__client.get(edit_uri) self.assertEqual(response.status_code, 200) - response = self.client.post(update_uri, data=self.__get_form()) + response = self.__client.post(update_uri, data=self.__get_form()) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) @@ -144,8 +144,8 @@ class OptionTestCase(unittest.TestCase): :return: None. """ from accounting.utils.options import options - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" - edit_uri: str = f"{PREFIX}/edit?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" + edit_uri: str = f"{PREFIX}/edit?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" form: dict[str, str] response: httpx.Response @@ -153,35 +153,35 @@ class OptionTestCase(unittest.TestCase): # Empty currency code form = self.__get_form() form["default_currency_code"] = " " - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Non-existing currency code form = self.__get_form() form["default_currency_code"] = "ZZZ" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Empty current account form = self.__get_form() form["default_ie_account_code"] = " " - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Non-existing current account form = self.__get_form() form["default_ie_account_code"] = "9999-999" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Not a current account form = self.__get_form() form["default_ie_account_code"] = Accounts.MEAL - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -189,7 +189,7 @@ class OptionTestCase(unittest.TestCase): form = self.__get_form() key = [x for x in form if x.endswith("-name")][0] form[key] = " " - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -197,7 +197,7 @@ class OptionTestCase(unittest.TestCase): form = self.__get_form() key = [x for x in form if x.endswith("-account_code")][0] form[key] = " " - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -207,7 +207,7 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-expense-") and x.endswith("-account_code")][0] form[key] = Accounts.SERVICE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -217,7 +217,7 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-income-") and x.endswith("-account_code")][0] form[key] = Accounts.UTILITIES - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -227,7 +227,7 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-expense-") and x.endswith("-account_code")][0] form[key] = Accounts.PAYABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -237,7 +237,7 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-income-") and x.endswith("-account_code")][0] form[key] = Accounts.RECEIVABLE - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) @@ -245,22 +245,22 @@ class OptionTestCase(unittest.TestCase): form = self.__get_form() key = [x for x in form if x.endswith("-description_template")][0] form[key] = " " - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], edit_uri) # Success, with malformed order - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(options.default_currency_code, "USD") self.assertEqual(options.default_ie_account_code, "1111-001") self.assertEqual(len(options.recurring.expenses), 0) self.assertEqual(len(options.recurring.incomes), 0) - response = self.client.post(update_uri, data=self.__get_form()) + response = self.__client.post(update_uri, data=self.__get_form()) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(options.default_currency_code, "EUR") self.assertEqual(options.default_ie_account_code, "0000-000") self.assertEqual(len(options.recurring.expenses), 4) @@ -281,11 +281,11 @@ class OptionTestCase(unittest.TestCase): # Success, with no recurring data form = self.__get_form() form = {x: form[x] for x in form if not x.startswith("recurring-")} - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): self.assertEqual(len(options.recurring.expenses), 0) self.assertEqual(len(options.recurring.incomes), 0) @@ -295,17 +295,17 @@ class OptionTestCase(unittest.TestCase): :return: None. """ from accounting.models import Option - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" form: dict[str, str] option: Option | None resource: httpx.Response - response = self.client.post(update_uri, data=self.__get_form()) + response = self.__client.post(update_uri, data=self.__get_form()) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): option = db.session.get(Option, "recurring") self.assertIsNotNone(option) timestamp: dt.datetime \ @@ -317,11 +317,11 @@ class OptionTestCase(unittest.TestCase): # The recurring setting was not modified form = self.__get_form() form["default_currency_code"] = "JPY" - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): option = db.session.get(Option, "recurring") self.assertIsNotNone(option) self.assertEqual(option.created_at, timestamp) @@ -333,11 +333,11 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-expense-") and x.endswith("-account_code")][0] form[key] = Accounts.MEAL - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): option = db.session.get(Option, "recurring") self.assertIsNotNone(option) self.assertLess(option.created_at, option.updated_at) @@ -350,16 +350,16 @@ class OptionTestCase(unittest.TestCase): from accounting.models import Option from accounting.utils.user import get_user_pk admin_username, editor_username = "admin", "editor" - detail_uri: str = f"{PREFIX}?next={self.encoded_next_uri}" + detail_uri: str = f"{PREFIX}?next={self.__encoded_next_uri}" update_uri: str = f"{PREFIX}/update" option: Option | None response: httpx.Response - response = self.client.post(update_uri, data=self.__get_form()) + response = self.__client.post(update_uri, data=self.__get_form()) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): editor_pk: int = get_user_pk(editor_username) option = db.session.get(Option, "recurring") self.assertIsNotNone(option) @@ -372,11 +372,11 @@ class OptionTestCase(unittest.TestCase): if x.startswith("recurring-expense-") and x.endswith("-account_code")][0] form[key] = Accounts.MEAL - response = self.client.post(update_uri, data=form) + response = self.__client.post(update_uri, data=form) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], detail_uri) - with self.app.app_context(): + with self.__app.app_context(): option = db.session.get(Option, "recurring") self.assertIsNotNone(option) self.assertEqual(option.created_by.username, editor_username) @@ -389,9 +389,9 @@ class OptionTestCase(unittest.TestCase): :return: The option form. """ if csrf_token is None: - csrf_token = self.csrf_token + csrf_token = self.__csrf_token return {"csrf_token": csrf_token, - "next": self.encoded_next_uri, + "next": self.__encoded_next_uri, "default_currency_code": "EUR", "default_ie_account_code": "0000-000", "recurring-expense-1-name": "Water bill", diff --git a/tests/test_report.py b/tests/test_report.py index 0aab8f4..ebb9253 100644 --- a/tests/test_report.py +++ b/tests/test_report.py @@ -41,17 +41,17 @@ class ReportTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -59,8 +59,8 @@ class ReportTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") - ReportTestData(self.app, "editor").populate() + client: httpx.Client = get_client(self.__app, "nobody") + ReportTestData(self.__app, "editor").populate() response: httpx.Response response = client.get(PREFIX) @@ -150,8 +150,8 @@ class ReportTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") - ReportTestData(self.app, "editor").populate() + client: httpx.Client = get_client(self.__app, "viewer") + ReportTestData(self.__app, "editor").populate() response: httpx.Response response = client.get(PREFIX) @@ -252,101 +252,101 @@ class ReportTestCase(unittest.TestCase): :return: None. """ - ReportTestData(self.app, "editor").populate() + ReportTestData(self.__app, "editor").populate() response: httpx.Response - response = self.client.get(PREFIX) + response = self.__client.get(PREFIX) self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}?as=csv") + response = self.__client.get(f"{PREFIX}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/journal") + response = self.__client.get(f"{PREFIX}/journal") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/journal?as=csv") + response = self.__client.get(f"{PREFIX}/journal?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/ledger") + response = self.__client.get(f"{PREFIX}/ledger") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/ledger?as=csv") + response = self.__client.get(f"{PREFIX}/ledger?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/income-expenses") + response = self.__client.get(f"{PREFIX}/income-expenses") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/income-expenses?as=csv") + response = self.__client.get(f"{PREFIX}/income-expenses?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/trial-balance") + response = self.__client.get(f"{PREFIX}/trial-balance") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/trial-balance?as=csv") + response = self.__client.get(f"{PREFIX}/trial-balance?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/income-statement") + response = self.__client.get(f"{PREFIX}/income-statement") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/income-statement?as=csv") + response = self.__client.get(f"{PREFIX}/income-statement?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/balance-sheet") + response = self.__client.get(f"{PREFIX}/balance-sheet") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/balance-sheet?as=csv") + response = self.__client.get(f"{PREFIX}/balance-sheet?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/unapplied") + response = self.__client.get(f"{PREFIX}/unapplied") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/unapplied?as=csv") + response = self.__client.get(f"{PREFIX}/unapplied?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}") self.assertEqual(response.status_code, 200) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/unmatched") + response = self.__client.get(f"{PREFIX}/unmatched") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/unmatched?as=csv") + response = self.__client.get(f"{PREFIX}/unmatched?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}") self.assertEqual(response.status_code, 200) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/search?q=Salary") + response = self.__client.get(f"{PREFIX}/search?q=Salary") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/search?q=Salary&as=csv") + response = self.__client.get(f"{PREFIX}/search?q=Salary&as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/search?q=薪水") + response = self.__client.get(f"{PREFIX}/search?q=薪水") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/search?q=薪水&as=csv") + response = self.__client.get(f"{PREFIX}/search?q=薪水&as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) @@ -357,91 +357,91 @@ class ReportTestCase(unittest.TestCase): """ response: httpx.Response - response = self.client.get(PREFIX) + response = self.__client.get(PREFIX) self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}?as=csv") + response = self.__client.get(f"{PREFIX}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/journal") + response = self.__client.get(f"{PREFIX}/journal") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/journal?as=csv") + response = self.__client.get(f"{PREFIX}/journal?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/ledger") + response = self.__client.get(f"{PREFIX}/ledger") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/ledger?as=csv") + response = self.__client.get(f"{PREFIX}/ledger?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/income-expenses") + response = self.__client.get(f"{PREFIX}/income-expenses") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/income-expenses?as=csv") + response = self.__client.get(f"{PREFIX}/income-expenses?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/trial-balance") + response = self.__client.get(f"{PREFIX}/trial-balance") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/trial-balance?as=csv") + response = self.__client.get(f"{PREFIX}/trial-balance?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/income-statement") + response = self.__client.get(f"{PREFIX}/income-statement") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/income-statement?as=csv") + response = self.__client.get(f"{PREFIX}/income-statement?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/balance-sheet") + response = self.__client.get(f"{PREFIX}/balance-sheet") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/balance-sheet?as=csv") + response = self.__client.get(f"{PREFIX}/balance-sheet?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/unapplied") + response = self.__client.get(f"{PREFIX}/unapplied") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/unapplied?as=csv") + response = self.__client.get(f"{PREFIX}/unapplied?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}") self.assertEqual(response.status_code, 200) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unapplied/USD/{Accounts.PAYABLE}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/unmatched") + response = self.__client.get(f"{PREFIX}/unmatched") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/unmatched?as=csv") + response = self.__client.get(f"{PREFIX}/unmatched?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}") self.assertEqual(response.status_code, 200) - response = self.client.get( + response = self.__client.get( f"{PREFIX}/unmatched/USD/{Accounts.PAYABLE}?as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) - response = self.client.get(f"{PREFIX}/search?q=Salary") + response = self.__client.get(f"{PREFIX}/search?q=Salary") self.assertEqual(response.status_code, 200) - response = self.client.get(f"{PREFIX}/search?q=Salary&as=csv") + response = self.__client.get(f"{PREFIX}/search?q=Salary&as=csv") self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["Content-Type"], CSV_MIME) diff --git a/tests/test_unmatched_offset.py b/tests/test_unmatched_offset.py index 1418cd4..cc83b60 100644 --- a/tests/test_unmatched_offset.py +++ b/tests/test_unmatched_offset.py @@ -42,19 +42,19 @@ class UnmatchedOffsetTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - with self.app.app_context(): + with self.__app.app_context(): from accounting.models import JournalEntry, JournalEntryLineItem JournalEntry.query.delete() JournalEntryLineItem.query.delete() - self.encoded_next_uri: str = encode_next(NEXT_URI) + self.__encoded_next_uri: str = encode_next(NEXT_URI) """The encoded next URI.""" - self.client: httpx.Client = get_client(self.app, "editor") + self.__client: httpx.Client = get_client(self.__app, "editor") """The user client.""" - self.csrf_token: str = get_csrf_token(self.client) + self.__csrf_token: str = get_csrf_token(self.__client) """The CSRF token.""" def test_nobody(self) -> None: @@ -62,14 +62,14 @@ class UnmatchedOffsetTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "nobody") + client: httpx.Client = get_client(self.__app, "nobody") csrf_token: str = get_csrf_token(client) - DifferentTestData(self.app, "nobody").populate() + DifferentTestData(self.__app, "nobody").populate() response: httpx.Response response = client.post(f"{PREFIX}/{Accounts.PAYABLE}", data={"csrf_token": csrf_token, - "next": self.encoded_next_uri}) + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 403) def test_viewer(self) -> None: @@ -77,14 +77,14 @@ class UnmatchedOffsetTestCase(unittest.TestCase): :return: None. """ - client: httpx.Client = get_client(self.app, "viewer") + client: httpx.Client = get_client(self.__app, "viewer") csrf_token: str = get_csrf_token(client) - DifferentTestData(self.app, "viewer").populate() + DifferentTestData(self.__app, "viewer").populate() response: httpx.Response response = client.post(f"{PREFIX}/{Accounts.PAYABLE}", data={"csrf_token": csrf_token, - "next": self.encoded_next_uri}) + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 403) def test_editor(self) -> None: @@ -92,12 +92,12 @@ class UnmatchedOffsetTestCase(unittest.TestCase): :return: None. """ - DifferentTestData(self.app, "editor").populate() + DifferentTestData(self.__app, "editor").populate() response: httpx.Response - response = self.client.post(f"{PREFIX}/{Accounts.PAYABLE}", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(f"{PREFIX}/{Accounts.PAYABLE}", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) @@ -108,9 +108,9 @@ class UnmatchedOffsetTestCase(unittest.TestCase): """ response: httpx.Response - response = self.client.post(f"{PREFIX}/{Accounts.PAYABLE}", - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(f"{PREFIX}/{Accounts.PAYABLE}", + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) @@ -122,7 +122,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase): from accounting.models import Currency, Account, JournalEntryLineItem from accounting.report.utils.offset_matcher import OffsetMatcher from accounting.template_globals import default_currency_code - data: DifferentTestData = DifferentTestData(self.app, "editor") + data: DifferentTestData = DifferentTestData(self.__app, "editor") data.populate() account: Account | None line_item: JournalEntryLineItem | None @@ -130,13 +130,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): match_uri: str response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): currency: Currency | None \ = db.session.get(Currency, default_currency_code()) assert currency is not None # The receivables - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -158,13 +158,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertIsNone(line_item.original_line_item_id) match_uri = f"{PREFIX}/{Accounts.RECEIVABLE}" - response = self.client.post(match_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(match_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -186,7 +186,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertEqual(line_item.original_line_item_id, data.l_r_or4d.id) # The payables - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -208,13 +208,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertIsNone(line_item.original_line_item_id) match_uri = f"{PREFIX}/{Accounts.PAYABLE}" - response = self.client.post(match_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(match_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -243,7 +243,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase): from accounting.models import Currency, Account, JournalEntryLineItem from accounting.report.utils.offset_matcher import OffsetMatcher from accounting.template_globals import default_currency_code - data: SameTestData = SameTestData(self.app, "editor") + data: SameTestData = SameTestData(self.__app, "editor") data.populate() account: Account | None line_item: JournalEntryLineItem | None @@ -251,13 +251,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): match_uri: str response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): currency: Currency | None \ = db.session.get(Currency, default_currency_code()) assert currency is not None # The receivables - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -286,13 +286,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertEqual(line_item.original_line_item_id, data.l_r_or2d.id) match_uri = f"{PREFIX}/{Accounts.RECEIVABLE}" - response = self.client.post(match_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(match_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.RECEIVABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -323,7 +323,7 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertEqual(line_item.original_line_item_id, data.l_r_or4d.id) # The payables - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) assert account is not None matcher = OffsetMatcher(currency, account) @@ -352,13 +352,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase): self.assertEqual(line_item.original_line_item_id, data.l_p_or2c.id) match_uri = f"{PREFIX}/{Accounts.PAYABLE}" - response = self.client.post(match_uri, - data={"csrf_token": self.csrf_token, - "next": self.encoded_next_uri}) + response = self.__client.post(match_uri, + data={"csrf_token": self.__csrf_token, + "next": self.__encoded_next_uri}) self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], NEXT_URI) - with self.app.app_context(): + with self.__app.app_context(): account = Account.find_by_code(Accounts.PAYABLE) assert account is not None matcher = OffsetMatcher(currency, account) diff --git a/tests/test_utils.py b/tests/test_utils.py index a550941..27a2dee 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -40,7 +40,7 @@ class NextUriTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" def test_next_uri(self) -> None: @@ -52,7 +52,7 @@ class NextUriTestCase(unittest.TestCase): """The test view with the next URI.""" current_uri: str = request.full_path if request.query_string \ else request.path - with self.app.app_context(): + with self.__app.app_context(): encoded_current: str = encode_next(current_uri) self.assertEqual(append_next(self.TARGET), f"{self.TARGET}?next={encoded_current}") @@ -60,19 +60,20 @@ class NextUriTestCase(unittest.TestCase): if request.method == "POST" else request.args["next"] self.assertEqual(inherit_next(self.TARGET), f"{self.TARGET}?next={encoded_next_uri}") - with self.app.app_context(): + with self.__app.app_context(): next_uri: str = decode_next(encoded_next_uri) self.assertEqual(or_next(self.TARGET), next_uri) return "" - self.app.add_url_rule("/test-next", view_func=test_next_uri_view, - methods=["GET", "POST"]) - client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER) + self.__app.add_url_rule("/test-next", view_func=test_next_uri_view, + methods=["GET", "POST"]) + client: httpx.Client = httpx.Client(app=self.__app, + base_url=TEST_SERVER) client.headers["Referer"] = TEST_SERVER csrf_token: str = get_csrf_token(client) response: httpx.Response - with self.app.app_context(): + with self.__app.app_context(): encoded_uri: str = encode_next(NEXT_URI) response = client.get(f"/test-next?next={encoded_uri}&q=abc&page-no=4") self.assertEqual(response.status_code, 200) @@ -92,9 +93,11 @@ class NextUriTestCase(unittest.TestCase): self.assertEqual(or_next(self.TARGET), self.TARGET) return "" - self.app.add_url_rule("/test-no-next", view_func=test_no_next_uri_view, - methods=["GET", "POST"]) - client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER) + self.__app.add_url_rule("/test-no-next", + view_func=test_no_next_uri_view, + methods=["GET", "POST"]) + client: httpx.Client = httpx.Client(app=self.__app, + base_url=TEST_SERVER) client.headers["Referer"] = TEST_SERVER csrf_token: str = get_csrf_token(client) response: httpx.Response @@ -116,10 +119,11 @@ class NextUriTestCase(unittest.TestCase): self.assertEqual(or_next(self.TARGET), self.TARGET) return "" - self.app.add_url_rule("/test-invalid-next", - view_func=test_invalid_next_uri_view, - methods=["GET", "POST"]) - client: httpx.Client = httpx.Client(app=self.app, base_url=TEST_SERVER) + self.__app.add_url_rule("/test-invalid-next", + view_func=test_invalid_next_uri_view, + methods=["GET", "POST"]) + client: httpx.Client = httpx.Client(app=self.__app, + base_url=TEST_SERVER) client.headers["Referer"] = TEST_SERVER csrf_token: str = get_csrf_token(client) next_uri: str @@ -204,28 +208,29 @@ class PaginationTestCase(unittest.TestCase): :return: None. """ - self.app: Flask = create_test_app() + self.__app: Flask = create_test_app() """The Flask application.""" - self.params: PaginationTestCase.Params = self.Params([], None, [], True) + self.__params: PaginationTestCase.Params \ + = self.Params([], None, [], True) """The testing pagination parameters.""" - @self.app.get("/test-pagination") + @self.__app.get("/test-pagination") def test_pagination_view() -> str: """The test view with the pagination.""" pagination: Pagination - if self.params.is_reversed is not None: + if self.__params.is_reversed is not None: pagination = Pagination[int]( - self.params.items, is_reversed=self.params.is_reversed) + self.__params.items, is_reversed=self.__params.is_reversed) else: - pagination = Pagination[int](self.params.items) - self.assertEqual(pagination.is_paged, self.params.is_paged) - self.assertEqual(pagination.list, self.params.result) + pagination = Pagination[int](self.__params.items) + self.assertEqual(pagination.is_paged, self.__params.is_paged) + self.assertEqual(pagination.list, self.__params.result) return "" - self.client: httpx.Client = httpx.Client(app=self.app, - base_url=TEST_SERVER) + self.__client: httpx.Client = httpx.Client(app=self.__app, + base_url=TEST_SERVER) """The user client.""" - self.client.headers["Referer"] = TEST_SERVER + self.__client.headers["Referer"] = TEST_SERVER def __test_success(self, query: str, items: range, result: range, is_paged: bool = True, @@ -242,9 +247,9 @@ class PaginationTestCase(unittest.TestCase): target: str = "/test-pagination" if query != "": target = f"{target}?{query}" - self.params = self.Params(list(items), is_reversed, - list(result), is_paged) - response: httpx.Response = self.client.get(target) + self.__params = self.Params(list(items), is_reversed, + list(result), is_paged) + response: httpx.Response = self.__client.get(target) self.assertEqual(response.status_code, 200) def __test_malformed(self, query: str, items: range, redirect_to: str, @@ -258,8 +263,8 @@ class PaginationTestCase(unittest.TestCase): :return: None. """ target: str = "/test-pagination" - self.params = self.Params(list(items), is_reversed, [], True) - response: httpx.Response = self.client.get(f"{target}?{query}") + self.__params = self.Params(list(items), is_reversed, [], True) + response: httpx.Response = self.__client.get(f"{target}?{query}") self.assertEqual(response.status_code, 302) self.assertEqual(response.headers["Location"], f"{target}?{redirect_to}")