src/accounting/account/forms.py

@@ -168,9 +168,7 @@ class AccountReorderForm:
         :param base: The base account.
         """
         self.base: BaseAccount = base
-        """The base account."""
         self.is_modified: bool = False
-        """Whether the order is modified."""
 
     def save_order(self) -> None:
         """Saves the order of the account.

src/accounting/forms.py

@@ -65,7 +65,6 @@ class IsDebitAccount:
         :param message: The error message.
         """
         self.__message: str | LazyString = message
-        """The error message."""
 
     def __call__(self, form: FlaskForm, field: StringField) -> None:
         if field.data is None:
@@ -86,7 +85,6 @@ class IsCreditAccount:
         :param message: The error message.
         """
         self.__message: str | LazyString = message
-        """The error message."""
 
     def __call__(self, form: FlaskForm, field: StringField) -> None:
         if field.data is None:

src/accounting/journal_entry/forms/journal_entry.py

@@ -151,6 +151,7 @@ class JournalEntryForm(FlaskForm):
         is_new: bool = obj.id is None
         if is_new:
             obj.id = new_id(JournalEntry)
+        self.date: DateField
         self.__set_date(obj, self.date.data)
         obj.note = self.note.data
 

src/accounting/journal_entry/forms/reorder.py

@@ -54,9 +54,7 @@ class JournalEntryReorderForm:
         :param date: The date.
         """
         self.date: dt.date = date
-        """The date."""
         self.is_modified: bool = False
-        """Whether the order is modified."""
 
     def save_order(self) -> None:
         """Saves the order of the account.

src/accounting/journal_entry/utils/description_editor.py

@@ -166,11 +166,8 @@ class DescriptionRecurring:
         :param account: The account.
         """
         self.name: str = name
-        """The name."""
         self.account: DescriptionAccount = DescriptionAccount(account, 0)
-        """The account."""
         self.description_template: str = description_template
-        """The description template."""
 
     @property
     def account_codes(self) -> list[str]:

src/accounting/locale.py

@@ -25,10 +25,8 @@ from flask_babel import LazyString, Domain
 from flask_babel_js import JAVASCRIPT, c2js
 
 translation_dir: Path = Path(__file__).parent / "translations"
-"""The directory of the translation files."""
 domain: Domain = Domain(translation_directories=[translation_dir],
                         domain="accounting")
-"""The message domain."""
 
 
 def gettext(string, **variables) -> str:
@@ -122,5 +120,6 @@ def init_app(app: Flask, bp: Blueprint) -> None:
     :param bp: The blueprint of the accounting application.
     :return: None.
     """
-    bp.add_url_rule("/_jstrans.js", "babel_catalog", __babel_js_catalog_view)
+    bp.add_url_rule("/_jstrans.js", "babel_catalog",
+                    __babel_js_catalog_view)
     app.jinja_env.globals["A_"] = domain.gettext

src/accounting/models.py

@@ -40,7 +40,7 @@ class BaseAccount(db.Model):
     __tablename__ = "accounting_base_accounts"
     """The table name."""
     code: Mapped[str] = mapped_column(primary_key=True)
-    """The account code."""
+    """The code."""
     title_l10n: Mapped[str] = mapped_column("title")
     """The title."""
     l10n: Mapped[list[BaseAccountL10n]] \
@@ -87,7 +87,7 @@ class BaseAccountL10n(db.Model):
         = mapped_column(db.ForeignKey(BaseAccount.code, onupdate="CASCADE",
                                       ondelete="CASCADE"),
                         primary_key=True)
-    """The account code."""
+    """The code of the account."""
     account: Mapped[BaseAccount] = db.relationship(back_populates="l10n")
     """The account."""
     locale: Mapped[str] = mapped_column(primary_key=True)
@@ -369,9 +369,9 @@ class Currency(db.Model):
     __tablename__ = "accounting_currencies"
     """The table name."""
     code: Mapped[str] = mapped_column(primary_key=True)
-    """The currency code."""
+    """The code."""
     name_l10n: Mapped[str] = mapped_column("name")
-    """The currency name."""
+    """The name."""
     created_at: Mapped[dt.datetime] \
         = mapped_column(db.DateTime(timezone=True),
                         server_default=db.func.now())
@@ -544,7 +544,7 @@ class JournalEntry(db.Model):
     date: Mapped[dt.date]
     """The date."""
     no: Mapped[int] = mapped_column(default=text("1"))
-    """The journal entry number under the date."""
+    """The account number under the date."""
     note: Mapped[str | None]
     """The note."""
     created_at: Mapped[dt.datetime] \

src/accounting/report/period/period.py

@@ -42,7 +42,7 @@ class Period:
         self.end: dt.date | None = end
         """The end of the period."""
         self.is_default: bool = False
-        """Whether this is the default period."""
+        """Whether the is the default period."""
         self.is_this_month: bool = False
         """Whether the period is this month."""
         self.is_last_month: bool = False

src/accounting/report/reports/balance_sheet.py

@@ -145,7 +145,6 @@ class AccountCollector:
             .filter(sa.or_(Account.id.in_({x.id for x in account_balances}),
                            Account.base_code == "3351",
                            Account.base_code == "3353")).all()
-        """The accounts."""
         account_by_id: dict[int, Account] \
             = {x.id: x for x in self.__all_accounts}
         self.accounts: list[ReportAccount] \
@@ -155,7 +154,6 @@ class AccountCollector:
                                             account_by_id[x.id],
                                             self.__period))
                for x in account_balances]
-        """The accounts on the balance sheet."""
         self.__add_accumulated()
         self.__add_current_period()
         self.accounts.sort(key=lambda x: (x.account.base_code, x.account.no))

src/accounting/report/reports/income_statement.py

@@ -106,7 +106,6 @@ class Section:
         """The subsections in the section."""
         self.accumulated: AccumulatedTotal \
             = AccumulatedTotal(accumulated_title)
-        """The accumulated total."""
 
     @property
     def total(self) -> Decimal:

src/accounting/utils/next_uri.py

@@ -75,7 +75,8 @@ def __get_next() -> str | None:
     if next_uri is None:
         return None
     try:
-        return decode_next(next_uri)
+        return URLSafeSerializer(current_app.config["SECRET_KEY"])\
+            .loads(next_uri, "next")
     except BadData:
         return None
 
@@ -106,16 +107,6 @@ def encode_next(uri: str) -> str:
         .dumps(uri, "next")
 
 
-def decode_next(uri: str) -> str:
-    """Decodes the encoded next URI.
-
-    :param uri: The encoded next URI.
-    :return: The next URI.
-    """
-    return URLSafeSerializer(current_app.config["SECRET_KEY"])\
-        .loads(uri, "next")
-
-
 def init_app(bp: Blueprint) -> None:
     """Initializes the application.
 

src/accounting/utils/options.py

@@ -39,11 +39,8 @@ class RecurringItem:
         :param description_template: The description template.
         """
         self.name: str = name
-        """The name."""
         self.account_code: str = account_code
-        """The account code."""
         self.description_template: str = description_template
-        """The description template."""
 
     @property
     def account_text(self) -> str:
@@ -64,10 +61,8 @@ class Recurring:
         """
         self.expenses: list[RecurringItem] \
             = [RecurringItem(x[0], x[1], x[2]) for x in data["expense"]]
-        """The recurring expenses."""
         self.incomes: list[RecurringItem] \
             = [RecurringItem(x[0], x[1], x[2]) for x in data["income"]]
-        """The recurring incomes."""
 
     @property
     def codes(self) -> set[str]:

src/accounting/utils/pagination.py

@@ -63,7 +63,6 @@ DEFAULT_PAGE_SIZE: int = 10
 """The default page size."""
 
 T = TypeVar("T")
-"""The pagination item type."""
 
 
 class Pagination(Generic[T]):

src/accounting/utils/user.py

@@ -27,7 +27,6 @@ from flask import g, Response
 from flask_sqlalchemy.model import Model
 
 T = TypeVar("T", bound=Model)
-"""The user data model data type."""
 
 
 class UserUtilityInterface(Generic[T], ABC):

tests/babel-utils-test-site.py

@@ -28,11 +28,8 @@ from babel.messages.frontend import CommandLineInterface
 from opencc import OpenCC
 
 root_dir: Path = Path(__file__).parent.parent
-"""The project root directory."""
 translation_dir: Path = root_dir / "tests" / "test_site" / "translations"
-"""The directory of the translation files."""
 domain: str = "messages"
-"""The message domain."""
 
 
 @click.group()

tests/babel-utils.py

@@ -28,11 +28,8 @@ from babel.messages.frontend import CommandLineInterface
 from opencc import OpenCC
 
 root_dir: Path = Path(__file__).parent.parent
-"""The project root directory."""
 translation_dir: Path = root_dir / "src" / "accounting" / "translations"
-"""The directory of the translation files."""
 domain: str = "accounting"
-"""The message domain."""
 
 
 @click.group()

tests/test_account.py

@@ -25,8 +25,8 @@ from flask import Flask
 
 from accounting.utils.next_uri import encode_next
 from test_site import db
-from testlib import NEXT_URI, create_test_app, get_client, get_csrf_token, \
-    set_locale, add_journal_entry
+from testlib import NEXT_URI, create_test_app, get_client, set_locale, \
+    add_journal_entry
 
 
 class AccountData:
@@ -72,35 +72,30 @@ class AccountTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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)
-            """The encoded next URI."""
+            self.encoded_next_uri: str = encode_next(NEXT_URI)
 
-        self.__client: httpx.Client = get_client(self.__app, "editor")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "editor")
         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,8 +106,7 @@ class AccountTestCase(unittest.TestCase):
         :return: None.
         """
         from accounting.models import Account
-        client: httpx.Client = get_client(self.__app, "nobody")
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, "nobody")
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -146,12 +140,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,8 +155,7 @@ class AccountTestCase(unittest.TestCase):
         :return: None.
         """
         from accounting.models import Account
-        client: httpx.Client = get_client(self.__app, "viewer")
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, "viewer")
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -196,12 +189,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 +206,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,97 +262,96 @@ 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",
@@ -382,71 +374,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:
@@ -460,14 +452,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 \
@@ -475,14 +467,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,
@@ -495,14 +487,13 @@ class AccountTestCase(unittest.TestCase):
         """
         from accounting.models import Account
         editor_username, admin_username = "editor", "admin"
-        client: httpx.Client = get_client(self.__app, admin_username)
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, admin_username)
         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)
@@ -514,7 +505,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)
@@ -532,51 +523,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},
@@ -593,53 +584,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:
@@ -651,15 +642,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")
@@ -679,14 +670,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)
@@ -702,34 +693,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")
@@ -737,7 +728,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
@@ -745,16 +736,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")

tests/test_base_account.py

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

tests/test_commands.py

@@ -40,10 +40,9 @@ class ConsoleCommandTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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 +61,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,
@@ -81,15 +80,14 @@ class ConsoleCommandTestCase(unittest.TestCase):
         from accounting.models import BaseAccount
 
         with open(data_dir / "base_accounts.csv") as fp:
-            rows: list[dict[str, str]] = list(csv.DictReader(fp))
-        data: dict[dict[str, Any]] \
-            = {x["code"]: {"code": x["code"],
-                           "title": x["title"],
-                           "l10n": {y[5:]: x[y]
-                                    for y in x if y.startswith("l10n-")}}
-               for x in rows}
+            data: dict[dict[str, Any]] \
+                = {x["code"]: {"code": x["code"],
+                               "title": x["title"],
+                               "l10n": {y[5:]: x[y]
+                                        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))
@@ -110,7 +108,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()
@@ -144,7 +142,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))

tests/test_currency.py

@@ -25,8 +25,8 @@ from flask import Flask
 
 from accounting.utils.next_uri import encode_next
 from test_site import db
-from testlib import NEXT_URI, create_test_app, get_client, get_csrf_token, \
-    set_locale, add_journal_entry
+from testlib import NEXT_URI, create_test_app, get_client, set_locale, \
+    add_journal_entry
 
 
 class CurrencyData:
@@ -65,32 +65,28 @@ class CurrencyTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "editor")
         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,8 +95,7 @@ class CurrencyTestCase(unittest.TestCase):
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "nobody")
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, "nobody")
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -136,8 +131,7 @@ class CurrencyTestCase(unittest.TestCase):
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "viewer")
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, "viewer")
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -175,34 +169,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,73 +211,72 @@ 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})
 
@@ -304,70 +297,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:
@@ -381,14 +374,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 \
@@ -396,14 +389,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,
@@ -416,14 +409,13 @@ class CurrencyTestCase(unittest.TestCase):
         """
         from accounting.models import Currency
         editor_username, admin_username = "editor", "admin"
-        client: httpx.Client = get_client(self.__app, admin_username)
-        csrf_token: str = get_csrf_token(client)
+        client, csrf_token = get_client(self.app, admin_username)
         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)
@@ -435,7 +427,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)
@@ -447,14 +439,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()
@@ -472,51 +464,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},
@@ -530,56 +522,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)

tests/test_description_editor.py

@@ -20,12 +20,11 @@
 import datetime as dt
 import unittest
 
-import httpx
 from flask import Flask
 
 from accounting.utils.next_uri import encode_next
 from testlib import NEXT_URI, Accounts, create_test_app, get_client, \
-    get_csrf_token, add_journal_entry
+    add_journal_entry
 
 
 class DescriptionEditorTestCase(unittest.TestCase):
@@ -37,20 +36,15 @@ class DescriptionEditorTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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)
-            """The encoded next URI."""
+            self.encoded_next_uri: str = encode_next(NEXT_URI)
 
-        self.__client: httpx.Client = get_client(self.__app, "editor")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "editor")
 
     def test_description_editor(self) -> None:
         """Test the description editor.
@@ -59,9 +53,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

tests/test_option.py

@@ -25,8 +25,7 @@ from flask import Flask
 
 from accounting.utils.next_uri import encode_next
 from test_site import db
-from testlib import NEXT_URI, Accounts, create_test_app, get_client, \
-    get_csrf_token
+from testlib import NEXT_URI, Accounts, create_test_app, get_client
 
 PREFIX: str = "/accounting/options"
 """The URL prefix for the option management."""
@@ -41,29 +40,23 @@ class OptionTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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)
-            """The encoded next URI."""
+            self.encoded_next_uri: str = encode_next(NEXT_URI)
 
-        self.__client: httpx.Client = get_client(self.__app, "admin")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "admin")
 
     def test_nobody(self) -> None:
         """Test the permission as nobody.
 
         :return: None.
         """
-        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}"
+        client, csrf_token = get_client(self.app, "nobody")
+        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 +74,9 @@ class OptionTestCase(unittest.TestCase):
 
         :return: None.
         """
-        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}"
+        client, csrf_token = get_client(self.app, "viewer")
+        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 +94,9 @@ class OptionTestCase(unittest.TestCase):
 
         :return: None.
         """
-        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}"
+        client, csrf_token = get_client(self.app, "editor")
+        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 +114,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 +135,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 +144,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 +180,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 +188,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 +198,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 +208,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 +218,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 +228,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 +236,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 +272,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 +286,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 +308,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 +324,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 +341,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 +363,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 +380,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",

tests/test_report.py

@@ -24,7 +24,7 @@ import httpx
 from flask import Flask
 
 from test_site.lib import BaseTestData
-from testlib import create_test_app, get_client, get_csrf_token, Accounts
+from testlib import create_test_app, get_client, Accounts
 
 PREFIX: str = "/accounting"
 """The URL prefix for the reports."""
@@ -41,26 +41,22 @@ class ReportTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "editor")
 
     def test_nobody(self) -> None:
         """Test the permission as nobody.
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "nobody")
-        ReportTestData(self.__app, "editor").populate()
+        client, csrf_token = get_client(self.app, "nobody")
+        ReportTestData(self.app, "editor").populate()
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -150,8 +146,8 @@ class ReportTestCase(unittest.TestCase):
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "viewer")
-        ReportTestData(self.__app, "editor").populate()
+        client, csrf_token = get_client(self.app, "viewer")
+        ReportTestData(self.app, "editor").populate()
         response: httpx.Response
 
         response = client.get(PREFIX)
@@ -252,101 +248,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 +353,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)
 

tests/test_site/__init__.py

@@ -23,13 +23,15 @@ from typing import Type
 
 from click.testing import Result
 from flask import Flask, Blueprint, render_template, redirect, Response, \
-    url_for
+    url_for, request
 from flask.testing import FlaskCliRunner
 from flask_babel_js import BabelJS
 from flask_sqlalchemy import SQLAlchemy
 from flask_wtf import CSRFProtect
 from sqlalchemy import Column
 
+from accounting.utils.next_uri import encode_next
+
 bp: Blueprint = Blueprint("home", __name__)
 """The global blueprint."""
 babel_js: BabelJS = BabelJS()

tests/test_site/lib.py

@@ -57,20 +57,13 @@ class JournalEntryLineItemData:
         :param original_line_item: The original journal entry line item.
         """
         self.journal_entry: JournalEntryData | None = None
-        """The journal entry data."""
         self.id: int = -1
-        """The journal entry line item ID."""
         self.no: int = -1
-        """The line item number under the journal entry and debit or credit."""
         self.original_line_item: JournalEntryLineItemData | None \
             = original_line_item
-        """The original journal entry line item."""
         self.account: str = account
-        """The account code."""
         self.description: str | None = description
-        """The description."""
         self.amount: Decimal = Decimal(amount)
-        """The amount."""
 
     def form(self, prefix: str, debit_credit: str, index: int,
              is_update: bool) -> dict[str, str]:
@@ -108,11 +101,8 @@ class JournalEntryCurrencyData:
         :param credit: The credit line items.
         """
         self.code: str = currency
-        """The currency code."""
         self.debit: list[JournalEntryLineItemData] = debit
-        """The debit line items."""
         self.credit: list[JournalEntryLineItemData] = credit
-        """The credit line items."""
 
     def form(self, index: int, is_update: bool) -> dict[str, str]:
         """Returns the currency as form data.
@@ -141,13 +131,9 @@ class JournalEntryData:
         :param currencies: The journal entry currency data.
         """
         self.id: int = -1
-        """The journal entry ID."""
         self.days: int = days
-        """The number of days before today."""
         self.currencies: list[JournalEntryCurrencyData] = currencies
-        """The journal entry currency data."""
         self.note: str | None = None
-        """The note."""
         for currency in self.currencies:
             for line_item in currency.debit:
                 line_item.journal_entry = self
@@ -204,17 +190,13 @@ class BaseTestData(ABC):
         :param username: The username.
         """
         self._app: Flask = app
-        """The Flask application."""
         with self._app.app_context():
             current_user: User | None = User.query\
                 .filter(User.username == username).first()
             assert current_user is not None
             self.__current_user_id: int = current_user.id
-            """The current user ID."""
             self.__journal_entries: list[dict[str, Any]] = []
-            """The data of the journal entries."""
             self.__line_items: list[dict[str, Any]] = []
-            """The data of the journal entry line items."""
             self._init_data()
 
     @abstractmethod

tests/test_site/locale.py

@@ -26,7 +26,6 @@ from werkzeug.datastructures import LanguageAccept
 from accounting.utils.next_uri import or_next
 
 bp: Blueprint = Blueprint("locale", __name__, url_prefix="/")
-"""The blueprint for the localization."""
 
 
 def get_locale():

tests/test_site/reset.py

@@ -29,7 +29,6 @@ from .lib import Accounts, JournalEntryLineItemData, JournalEntryData, \
     JournalEntryCurrencyData, BaseTestData
 
 bp: Blueprint = Blueprint("reset", __name__, url_prefix="/")
-"""The blueprint for the data reset."""
 
 
 @bp.get("reset", endpoint="reset-page")

tests/test_site/templates/home.html

@@ -25,7 +25,7 @@ First written: 2023/1/27
 
 {% block content %}
 
-<p>{{ _("This is the live demonstration of the Mia! Accounting project.  Please <a href=\"%(url)s\">log in</a> to continue.", url=url_for("auth.login")) }}</p>
+<p>{{ _("This is the live demonstration of the Mia! Accounting project.  Please <a href=\"/login?next=%%2Faccounting\">log in</a> to continue.") }}</p>
 
 <p>{{ _("You may also want to check the <a href=\"https://mia-accounting.readthedocs.io\">full documentation</a> and the <a href=\"https://github.com/imacat/mia-accounting\">Github repository</a>.") }}</p>
 

tests/test_site/translations/zh_Hant/LC_MESSAGES/messages.po

@@ -9,8 +9,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: mia-accounting-test-site 1.0.0\n"
 "Report-Msgid-Bugs-To: imacat@mail.imacat.idv.tw\n"
-"POT-Creation-Date: 2023-06-10 10:42+0800\n"
-"PO-Revision-Date: 2023-06-10 10:43+0800\n"
+"POT-Creation-Date: 2023-04-12 17:59+0800\n"
+"PO-Revision-Date: 2023-04-12 18:00+0800\n"
 "Last-Translator: imacat <imacat@mail.imacat.idv.tw>\n"
 "Language: zh_Hant\n"
 "Language-Team: zh_Hant <imacat@mail.imacat.idv.tw>\n"
@@ -24,7 +24,7 @@ msgstr ""
 msgid "The sample data are emptied and reset successfully."
 msgstr "範例資料已清空重設。"
 
-#: tests/test_site/reset.py:69
+#: tests/test_site/reset.py:68
 msgid "The database is emptied successfully."
 msgstr "資料庫已清空。"
 
@@ -61,8 +61,8 @@ msgstr "Mia! Accounting 示範站"
 #, python-format
 msgid ""
 "This is the live demonstration of the Mia! Accounting project.  Please <a"
-" href=\"%(url)s\">log in</a> to continue."
-msgstr "這是 Mia! Accounting 專案的示範站。請先<a href=\"%(url)s\">登入</a>。"
+" href=\"/login?next=%%2Faccounting\">log in</a> to continue."
+msgstr "這是 Mia! Accounting 專案的示範站。請先<a href=\"/login?next=%%2Faccounting\">登入</a>。"
 
 #: tests/test_site/templates/home.html:30
 msgid ""

tests/test_unmatched_offset.py

@@ -26,8 +26,7 @@ from accounting.utils.next_uri import encode_next
 from test_site import db
 from test_site.lib import JournalEntryCurrencyData, JournalEntryData, \
     BaseTestData
-from testlib import NEXT_URI, create_test_app, get_client, get_csrf_token, \
-    Accounts
+from testlib import NEXT_URI, create_test_app, get_client, Accounts
 
 PREFIX: str = "/accounting/match-offsets/USD"
 """The URL prefix for the unmatched offset management."""
@@ -42,34 +41,28 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
 
-        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)
-            """The encoded next URI."""
+            self.encoded_next_uri: str = encode_next(NEXT_URI)
 
-        self.__client: httpx.Client = get_client(self.__app, "editor")
-        """The user client."""
-        self.__csrf_token: str = get_csrf_token(self.__client)
-        """The CSRF token."""
+        self.client, self.csrf_token = get_client(self.app, "editor")
 
     def test_nobody(self) -> None:
         """Test the permission as nobody.
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "nobody")
-        csrf_token: str = get_csrf_token(client)
-        DifferentTestData(self.__app, "nobody").populate()
+        client, csrf_token = get_client(self.app, "nobody")
+        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 +70,13 @@ class UnmatchedOffsetTestCase(unittest.TestCase):
 
         :return: None.
         """
-        client: httpx.Client = get_client(self.__app, "viewer")
-        csrf_token: str = get_csrf_token(client)
-        DifferentTestData(self.__app, "viewer").populate()
+        client, csrf_token = get_client(self.app, "viewer")
+        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 +84,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 +100,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 +114,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 +122,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 +150,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 +178,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 +200,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 +235,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 +243,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 +278,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 +315,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 +344,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)
@@ -418,22 +410,18 @@ class DifferentTestData(BaseTestData):
             50, [JournalEntryCurrencyData(
                 "USD", [self.l_r_or1d, self.l_r_or4d],
                 [self.l_r_or1c, self.l_r_or4c])])
-        """The receivable original journal entry #1."""
         self.j_r_or2: JournalEntryData = JournalEntryData(
             30, [JournalEntryCurrencyData(
                 "USD", [self.l_r_or2d, self.l_r_or3d],
                 [self.l_r_or2c, self.l_r_or3c])])
-        """The receivable original journal entry #2"""
         self.j_p_or1: JournalEntryData = JournalEntryData(
             40, [JournalEntryCurrencyData(
                 "USD", [self.l_p_or1d, self.l_p_or4d],
                 [self.l_p_or1c, self.l_p_or4c])])
-        """The payable original journal entry #1."""
         self.j_p_or2: JournalEntryData = JournalEntryData(
             20, [JournalEntryCurrencyData(
                 "USD", [self.l_p_or2d, self.l_p_or3d],
                 [self.l_p_or2c, self.l_p_or3c])])
-        """The payable original journal entry #2."""
 
         self._add_journal_entry(self.j_r_or1)
         self._add_journal_entry(self.j_r_or2)
@@ -468,29 +456,23 @@ class DifferentTestData(BaseTestData):
         self.j_r_of1: JournalEntryData = JournalEntryData(
             25, [JournalEntryCurrencyData(
                 "USD", [self.l_r_of1d], [self.l_r_of1c])])
-        """The offset journal entry to the receivable #1."""
         self.j_r_of2: JournalEntryData = JournalEntryData(
             20, [JournalEntryCurrencyData(
                 "USD", [self.l_r_of2d, self.l_r_of3d, self.l_r_of4d],
                 [self.l_r_of2c, self.l_r_of3c, self.l_r_of4c])])
-        """The offset journal entry to the receivable #2."""
         self.j_r_of3: JournalEntryData = JournalEntryData(
             15, [JournalEntryCurrencyData(
                 "USD", [self.l_r_of5d], [self.l_r_of5c])])
-        """The offset journal entry to the receivable #3."""
         self.j_p_of1: JournalEntryData = JournalEntryData(
             15, [JournalEntryCurrencyData(
                 "USD", [self.l_p_of1d], [self.l_p_of1c])])
-        """The offset journal entry to the payable #1."""
         self.j_p_of2: JournalEntryData = JournalEntryData(
             10, [JournalEntryCurrencyData(
                 "USD", [self.l_p_of2d, self.l_p_of3d, self.l_p_of4d],
                 [self.l_p_of2c, self.l_p_of3c, self.l_p_of4c])])
-        """The offset journal entry to the payable #2."""
         self.j_p_of3: JournalEntryData = JournalEntryData(
             5, [JournalEntryCurrencyData(
                 "USD", [self.l_p_of5d], [self.l_p_of5c])])
-        """The offset journal entry to the payable #3."""
 
         self._add_journal_entry(self.j_r_of1)
         self._add_journal_entry(self.j_r_of2)

tests/test_utils.py

@@ -22,9 +22,9 @@ from urllib.parse import quote_plus
 
 import httpx
 from flask import Flask, request
+from itsdangerous import URLSafeSerializer
 
-from accounting.utils.next_uri import append_next, inherit_next, or_next, \
-    encode_next, decode_next
+from accounting.utils.next_uri import append_next, inherit_next, or_next
 from accounting.utils.pagination import Pagination, DEFAULT_PAGE_SIZE
 from accounting.utils.query import parse_query_keywords
 from testlib import TEST_SERVER, create_test_app, get_csrf_token, NEXT_URI
@@ -40,8 +40,9 @@ class NextUriTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
+        self.app: Flask = create_test_app()
+        self.serializer: URLSafeSerializer \
+            = URLSafeSerializer(self.app.config["SECRET_KEY"])
 
     def test_next_uri(self) -> None:
         """Tests the next URI utilities with the next URI.
@@ -52,29 +53,23 @@ 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():
-                encoded_current: str = encode_next(current_uri)
             self.assertEqual(append_next(self.TARGET),
-                             f"{self.TARGET}?next={encoded_current}")
-            encoded_next_uri: str = request.form["next"] \
-                if request.method == "POST" else request.args["next"]
+                             f"{self.TARGET}?next={self.__encode(current_uri)}")
+            next_uri: str = request.form["next"] 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():
-                next_uri: str = decode_next(encoded_next_uri)
-            self.assertEqual(or_next(self.TARGET), next_uri)
+                             f"{self.TARGET}?next={next_uri}")
+            self.assertEqual(or_next(self.TARGET), self.__decode(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():
-            encoded_uri: str = encode_next(NEXT_URI)
+        encoded_uri: str = self.__encode(NEXT_URI)
         response = client.get(f"/test-next?next={encoded_uri}&q=abc&page-no=4")
         self.assertEqual(response.status_code, 200)
         response = client.post("/test-next", data={"csrf_token": csrf_token,
@@ -93,11 +88,9 @@ 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
@@ -119,11 +112,10 @@ 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
@@ -140,6 +132,22 @@ class NextUriTestCase(unittest.TestCase):
                                      "next": next_uri})
         self.assertEqual(response.status_code, 200)
 
+    def __encode(self, uri: str) -> str:
+        """Encodes the next URI.
+
+        :param uri: The next URI.
+        :return: The encoded next URI.
+        """
+        return self.serializer.dumps(uri, "next")
+
+    def __decode(self, uri: str) -> str:
+        """Decodes the next URI.
+
+        :param uri: The encoded next URI.
+        :return: The next URI.
+        """
+        return self.serializer.loads(uri, "next")
+
 
 class QueryKeywordParserTestCase(unittest.TestCase):
     """The test case for the query keyword parser."""
@@ -182,7 +190,7 @@ class PaginationTestCase(unittest.TestCase):
     """The test case for pagination."""
 
     class Params:
-        """The testing pagination parameters."""
+        """The testing parameters."""
 
         def __init__(self, items: list[int], is_reversed: bool | None,
                      result: list[int], is_paged: bool):
@@ -194,13 +202,9 @@ class PaginationTestCase(unittest.TestCase):
             :param is_paged: Whether we need pagination.
             """
             self.items: list[int] = items
-            """All the items in the list."""
             self.is_reversed: bool | None = is_reversed
-            """Whether the default page is the last page."""
             self.result: list[int] = result
-            """The expected items on the page."""
             self.is_paged: bool = is_paged
-            """Whether we need pagination."""
 
     def setUp(self) -> None:
         """Sets up the test.
@@ -208,29 +212,24 @@ class PaginationTestCase(unittest.TestCase):
 
         :return: None.
         """
-        self.__app: Flask = create_test_app()
-        """The Flask application."""
-        self.__params: PaginationTestCase.Params \
-            = self.Params([], None, [], True)
-        """The testing pagination parameters."""
+        self.app: Flask = create_test_app()
+        self.params = self.Params([], None, [], True)
 
-        @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)
-        """The user client."""
-        self.__client.headers["Referer"] = TEST_SERVER
+        self.client = httpx.Client(app=self.app, base_url=TEST_SERVER)
+        self.client.headers["Referer"] = TEST_SERVER
 
     def __test_success(self, query: str, items: range,
                        result: range, is_paged: bool = True,
@@ -247,9 +246,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,
@@ -263,8 +262,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}")

tests/testlib.py

@@ -89,12 +89,12 @@ def get_csrf_token(client: httpx.Client) -> str:
     return client.get("/.csrf-token").text
 
 
-def get_client(app: Flask, username: str) -> httpx.Client:
+def get_client(app: Flask, username: str) -> tuple[httpx.Client, str]:
     """Returns a user client.
 
     :param app: The Flask application.
     :param username: The username.
-    :return: The user client.
+    :return: A tuple of the client and the CSRF token.
     """
     client: httpx.Client = httpx.Client(app=app, base_url=TEST_SERVER)
     client.headers["Referer"] = TEST_SERVER
@@ -107,7 +107,7 @@ def get_client(app: Flask, username: str) -> httpx.Client:
                                                  "username": username})
     assert response.status_code == 302
     assert response.headers["Location"] == NEXT_URI
-    return client
+    return client, csrf_token
 
 
 def set_locale(app: Flask, client: httpx.Client, csrf_token: str,

tests/testlib_journal_entry.py

@@ -25,7 +25,7 @@ from secrets import randbelow
 from flask import Flask
 
 from test_site import db
-from testlib import Accounts
+from testlib import NEXT_URI, Accounts
 
 NON_EMPTY_NOTE: str = "  This is \n\na test."
 """The stripped content of an non-empty note."""