wbaccounting 2.2.1__py2.py3-none-any.whl

wbaccounting/serializers/transactions.py

@@ -0,0 +1,50 @@
+from wbaccounting.models import Transaction
+from wbcore import serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import BankingContactRepresentationSerializer
+
+
+class TransactionRepresentationSerializer(serializers.RepresentationSerializer):
+    _bank_account = BankingContactRepresentationSerializer(source="bank_account")
+    _detail = serializers.HyperlinkField(reverse_name="wbaccounting:transaction-detail")
+
+    class Meta:
+        model = Transaction
+        fields = ("id", "booking_date", "bank_account", "_bank_account", "value", "_detail")
+
+
+class TransactionModelSerializer(serializers.ModelSerializer):
+    _bank_account = BankingContactRepresentationSerializer(source="bank_account")
+    _from_bank_account = BankingContactRepresentationSerializer(source="from_bank_account")
+    _to_bank_account = BankingContactRepresentationSerializer(source="to_bank_account")
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    bank_account_currency_symbol = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Transaction
+        decorators = {
+            "value": serializers.decorator(
+                decorator_type="text", position="left", value="{{bank_account_currency_symbol}}"
+            ),
+            "value_local_ccy": serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+        }
+        fields = (
+            "id",
+            "booking_date",
+            "value_date",
+            "bank_account",
+            "_bank_account",
+            "from_bank_account",
+            "_from_bank_account",
+            "to_bank_account",
+            "_to_bank_account",
+            "currency",
+            "_currency",
+            "fx_rate",
+            "value_local_ccy",
+            "description",
+            "value",
+            "bank_account_currency_symbol",
+        )

wbaccounting/tests/conftest.py

@@ -0,0 +1,65 @@
+from decimal import Decimal
+
+import factory
+import pytest
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbaccounting.factories import (
+    BookingEntryFactory,
+    EntryAccountingInformationFactory,
+    InvoiceFactory,
+    InvoiceTypeFactory,
+    LocalCurrencyTransactionFactory,
+    TransactionFactory,
+)
+from wbcore.contrib.authentication.factories import (
+    SuperUserFactory,
+    UserActivityFactory,
+    UserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories import (
+    BankingContactFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.tests.conftest import *
+
+register(BookingEntryFactory)
+register(InvoiceFactory)
+register(InvoiceTypeFactory)
+register(EntryAccountingInformationFactory)
+
+register(TransactionFactory)
+register(TransactionFactory, "transaction_no_value_date", value_date=None)
+register(
+    TransactionFactory,
+    "transaction_fx",
+    fx_rate=factory.Faker("pydecimal", min_value=Decimal(0.1), max_value=Decimal(0.9)),
+)
+register(LocalCurrencyTransactionFactory, "transaction_local_ccy")
+register(
+    LocalCurrencyTransactionFactory,
+    "transaction_local_ccy_fx",
+    fx_rate=factory.Faker("pydecimal", min_value=Decimal(0.1), max_value=Decimal(0.9)),
+)
+
+
+register(CurrencyFactory)
+register(CurrencyFXRatesFactory)
+
+register(EntryFactory)
+register(UserFactory)
+register(PersonFactory)
+register(SuperUserFactory)
+register(UserActivityFactory)
+register(BankingContactFactory)
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbaccounting"))
+
+
+@pytest.fixture
+def booking_entries(request, booking_entry_factory):
+    return [booking_entry_factory.create() for _ in range(request.param)]

wbaccounting/tests/test_displays/test_booking_entries.py

@@ -0,0 +1 @@
+import pytest

wbaccounting/tests/test_models/test_booking_entries.py

@@ -0,0 +1,119 @@
+from decimal import Decimal
+
+import pytest
+from pytest_factoryboy import LazyFixture
+from wbaccounting.models import BookingEntry, EntryAccountingInformation, Invoice
+from wbcore.contrib.authentication.models import User
+
+
+@pytest.mark.django_db
+class TestBookingEntry:
+    def test_str(self, booking_entry: BookingEntry):
+        assert str(booking_entry) == booking_entry.title
+
+    @pytest.mark.parametrize(
+        "method,return_value",
+        [
+            ("get_endpoint_basename", "wbaccounting:bookingentry"),
+            ("get_representation_value_key", "id"),
+            ("get_representation_label_key", "{{title}}"),
+            ("get_representation_endpoint", "wbaccounting:bookingentryrepresentation-list"),
+        ],
+    )
+    def test_wbmodel_methods(self, method: str, return_value: str):
+        assert getattr(BookingEntry, method)() == return_value
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    def test_filter_for_user_no_superuser(self, booking_entry: BookingEntry, user: User):
+        booking_entries = BookingEntry.objects.filter_for_user(user)  # type: ignore
+        assert booking_entry not in booking_entries
+
+    @pytest.mark.parametrize("user__is_superuser", [True])
+    def test_filter_for_user_superuser(self, booking_entry: BookingEntry, user: User):
+        booking_entries = BookingEntry.objects.filter_for_user(user)  # type: ignore
+        assert booking_entry in booking_entries
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_bookingentry"])])
+    @pytest.mark.parametrize("booking_entry__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [False])
+    def test_filter_for_user_public_counterparty(
+        self, booking_entry: BookingEntry, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        booking_entries = BookingEntry.objects.filter_for_user(user)  # type: ignore
+        assert booking_entry in booking_entries
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_bookingentry"])])
+    @pytest.mark.parametrize("booking_entry__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty(
+        self, booking_entry: BookingEntry, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        booking_entries = BookingEntry.objects.filter_for_user(user)  # type: ignore
+        assert booking_entry not in booking_entries
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_bookingentry"])])
+    @pytest.mark.parametrize("booking_entry__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty_with_exempt(
+        self, booking_entry: BookingEntry, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        entry_accounting_information.exempt_users.add(user)
+        booking_entries = BookingEntry.objects.filter_for_user(user)  # type: ignore
+        assert booking_entry in booking_entries
+
+    @pytest.mark.parametrize("booking_entry__net_value", [Decimal(90)])
+    @pytest.mark.parametrize("booking_entry__gross_value", [None])
+    @pytest.mark.parametrize("booking_entry__vat", [Decimal(0.1)])
+    def test_net_without_gross(self, booking_entry: BookingEntry):
+        assert pytest.approx(booking_entry.gross_value) == Decimal(99)
+
+    @pytest.mark.parametrize("booking_entry__net_value", [None])
+    @pytest.mark.parametrize("booking_entry__gross_value", [Decimal(99)])
+    @pytest.mark.parametrize("booking_entry__vat", [Decimal(0.1)])
+    def test_gross_without_net(self, booking_entry: BookingEntry):
+        assert pytest.approx(booking_entry.net_value) == Decimal(90)
+
+    @pytest.mark.parametrize("booking_entry__net_value", [Decimal(90)])
+    @pytest.mark.parametrize("booking_entry__gross_value", [Decimal(100)])
+    @pytest.mark.parametrize("booking_entry__vat", [Decimal(0.1)])
+    def test_net_with_gross(self, booking_entry: BookingEntry):
+        assert pytest.approx(booking_entry.gross_value) == Decimal(99)
+
+    @pytest.mark.parametrize("booking_entry__net_value", [None])
+    @pytest.mark.parametrize("booking_entry__gross_value", [None])
+    @pytest.mark.parametrize("booking_entry__vat", [Decimal(0.1)])
+    def test_net_and_gross_none(self, booking_entry: BookingEntry):
+        assert booking_entry.net_value == Decimal(0) and booking_entry.gross_value == Decimal(0)
+
+    def test_invoice_value_same_currency(self, booking_entry: BookingEntry):
+        assert booking_entry.net_value == booking_entry.invoice_net_value
+        assert booking_entry.gross_value == booking_entry.invoice_gross_value
+
+    def test_invoice_value_different_currency(
+        self, booking_entry: BookingEntry, invoice: Invoice, currency_factory, mocker
+    ):
+        # Change the invoice currency
+        invoice.invoice_currency = currency_factory.create()
+        invoice.save()
+
+        # Patch the currency convert method to no rely on the database
+        mocker.patch("wbcore.contrib.currency.models.Currency.convert", return_value=Decimal(1.1))
+        # Run the save method to trigger fx computation
+        booking_entry.save()
+        assert booking_entry.invoice_net_value == pytest.approx(booking_entry.net_value * booking_entry.invoice_fx_rate)  # type: ignore
+
+    def test_invoice_save_on_change(self, booking_entry: BookingEntry, mocker):
+        mocked_save = mocker.patch("wbaccounting.models.invoice.Invoice.save", autospec=True)
+        booking_entry.save()
+        mocked_save.assert_called_once()
+
+    def test_invoice_delete_on_change(self, booking_entry: BookingEntry, mocker):
+        mocked_save = mocker.patch("wbaccounting.models.invoice.Invoice.save", autospec=True)
+        booking_entry.delete()
+        mocked_save.assert_called_once()

wbaccounting/tests/test_models/test_entry_accounting_information.py

@@ -0,0 +1,81 @@
+import pytest
+from dynamic_preferences.registries import global_preferences_registry
+from wbaccounting.models import BookingEntry, EntryAccountingInformation
+from wbaccounting.models.entry_accounting_information import (
+    default_currency,
+    default_email_body,
+)
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.currency.models import Currency
+
+
+@pytest.mark.django_db
+class TestEntryAccountingInformation:
+    def test_str(self, entry_accounting_information: EntryAccountingInformation):
+        assert str(entry_accounting_information) == f"Counterparty: {entry_accounting_information.entry.computed_str}"
+
+    @pytest.mark.parametrize(
+        "method,return_value",
+        [
+            ("get_endpoint_basename", "wbaccounting:entryaccountinginformation"),
+            ("get_representation_value_key", "id"),
+            ("get_representation_label_key", "{{entry_repr}}"),
+            ("get_representation_endpoint", "wbaccounting:entryaccountinginformationrepresentation-list"),
+        ],
+    )
+    def test_wbmodel_methods(self, method: str, return_value: str):
+        assert getattr(EntryAccountingInformation, method)() == return_value
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    def test_filter_for_user_no_superuser(self, entry_accounting_information: EntryAccountingInformation, user: User):
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information not in entry_accounting_information_list
+
+    @pytest.mark.parametrize("user__is_superuser", [True])
+    def test_filter_for_user_superuser(self, entry_accounting_information: EntryAccountingInformation, user: User):
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information in entry_accounting_information_list
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_entryaccountinginformation"])])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [False])
+    def test_filter_for_user_public_counterparty(
+        self, entry_accounting_information: EntryAccountingInformation, user: User
+    ):
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information in entry_accounting_information_list
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_entryaccountinginformation"])])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty(
+        self, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information not in entry_accounting_information_list
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_entryaccountinginformation"])])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty_with_exempt(
+        self, booking_entry: BookingEntry, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        entry_accounting_information.exempt_users.add(user)
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information in entry_accounting_information_list
+
+    def test_default_email_body(self):
+        assert default_email_body() == ""
+
+    def test_custom_default_email_body(self):
+        global_preferences_registry.manager()["wbaccounting__invoice_email_body"] = "Custom Body"
+        assert default_email_body() == "Custom Body"
+
+    def test_default_currency(self):
+        assert default_currency() is None
+
+    def test_custom_default_currency(self, currency: Currency):
+        global_preferences_registry.manager()[
+            "wbaccounting__default_entry_account_information_currency_key"
+        ] = currency.key
+        assert default_currency().pk is currency.pk

wbaccounting/tests/test_models/test_invoice_types.py

@@ -0,0 +1,21 @@
+import pytest
+from wbaccounting.models import InvoiceType
+
+
+@pytest.mark.django_db
+class TestInvoiceType:
+    def test_str(self, invoice_type: InvoiceType):
+        assert str(invoice_type) == invoice_type.name
+
+    @pytest.mark.parametrize(
+        "method,return_value",
+        [
+            ("get_endpoint_basename", "wbaccounting:invoicetype"),
+            ("get_representation_value_key", "id"),
+            ("get_representation_label_key", "{{name}}"),
+            ("get_representation_endpoint", "wbaccounting:invoicetyperepresentation-list"),
+        ],
+    )
+    def test_wbmodel_methods(self, method: str, return_value: str):
+        assert getattr(InvoiceType, method)() == return_value
+

wbaccounting/tests/test_models/test_invoices.py

@@ -0,0 +1,73 @@
+import pytest
+from dynamic_preferences.models import GlobalPreferenceModel
+from dynamic_preferences.registries import global_preferences_registry
+from pytest_factoryboy.fixture import LazyFixture
+from wbaccounting.models import BookingEntry, EntryAccountingInformation, Invoice
+from wbaccounting.models.entry_accounting_information import (
+    default_email_body,
+    default_currency,
+)
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.currency.models import Currency
+
+
+@pytest.mark.django_db
+class TestInvoice:
+    def test_str(self, invoice: Invoice):
+        assert str(invoice) == invoice.title
+
+    @pytest.mark.parametrize(
+        "method,return_value",
+        [
+            ("get_endpoint_basename", "wbaccounting:invoice"),
+            ("get_representation_value_key", "id"),
+            ("get_representation_label_key", "{{title}} ({{invoice_date}})"),
+            ("get_representation_endpoint", "wbaccounting:invoicerepresentation-list"),
+        ],
+    )
+    def test_wbmodel_methods(self, method: str, return_value: str):
+        assert getattr(Invoice, method)() == return_value
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    def test_filter_for_user_no_superuser(self, invoice: Invoice, user: User):
+        invoices = Invoice.objects.filter_for_user(user)  # type: ignore
+        assert invoice not in invoices
+
+    @pytest.mark.parametrize("user__is_superuser", [True])
+    def test_filter_for_user_superuser(self, invoice: Invoice, user: User):
+        invoices = Invoice.objects.filter_for_user(user)  # type: ignore
+        assert invoice in invoices
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_invoice"])])
+    @pytest.mark.parametrize("invoice__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [False])
+    def test_filter_for_user_public_counterparty(
+        self, invoice: Invoice, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        invoices = Invoice.objects.filter_for_user(user)  # type: ignore
+        assert invoice in invoices
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_entryaccountinginformation"])])
+    @pytest.mark.parametrize("invoice__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty(
+        self, user: User, invoice: Invoice, entry_accounting_information: EntryAccountingInformation
+    ):
+        invoices = Invoice.objects.filter_for_user(user)  # type: ignore
+        assert invoice not in invoices
+
+    @pytest.mark.parametrize("user__is_superuser", [False])
+    @pytest.mark.parametrize("user__user_permissions", [(["wbaccounting.view_entryaccountinginformation"])])
+    @pytest.mark.parametrize("invoice__counterparty", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__entry", [LazyFixture("entry")])
+    @pytest.mark.parametrize("entry_accounting_information__counterparty_is_private", [True])
+    def test_filter_for_user_private_counterparty_with_exempt(
+        self, invoice: Invoice, user: User, entry_accounting_information: EntryAccountingInformation
+    ):
+        entry_accounting_information.exempt_users.add(user)
+        entry_accounting_information_list = EntryAccountingInformation.objects.filter_for_user(user)  # type: ignore
+        assert entry_accounting_information in entry_accounting_information_list

wbaccounting/tests/test_models/test_transactions.py

@@ -0,0 +1,40 @@
+import pytest
+from wbaccounting.models import Transaction
+
+
+@pytest.mark.django_db
+class TestTransaction:
+    def test_str(self, transaction: Transaction):
+        assert str(transaction) == f"{transaction.booking_date:%d.%m.%Y}: {transaction.value:.2f}"
+
+    @pytest.mark.parametrize(
+        "method,return_value",
+        [
+            ("get_endpoint_basename", "wbaccounting:transaction"),
+            ("get_representation_value_key", "id"),
+            ("get_representation_label_key", "{{booking_date}}: {{value}}"),
+            ("get_representation_endpoint", "wbaccounting:transactionrepresentation-list"),
+        ],
+    )
+    def test_wbmodel_methods(self, method: str, return_value: str):
+        assert getattr(Transaction, method)() == return_value
+
+    def test_no_value_date(self, transaction_no_value_date: Transaction):
+        assert transaction_no_value_date.value_date == transaction_no_value_date.booking_date
+
+    def test_value(self, transaction: Transaction):
+        assert pytest.approx(transaction.value_local_ccy) == transaction.value
+
+    def test_value_different_fx_rate(self, transaction_fx: Transaction):
+        tfx = transaction_fx
+        assert tfx.value is not None
+        assert pytest.approx(tfx.value / tfx.fx_rate) == pytest.approx(tfx.value_local_ccy)
+
+    def test_local_ccy(self, transaction_local_ccy: Transaction):
+        tlc = transaction_local_ccy
+        assert pytest.approx(tlc.value) == tlc.value_local_ccy
+
+    def test_local_ccy_different_fx_rate(self, transaction_local_ccy_fx: Transaction):
+        tlcf = transaction_local_ccy_fx
+        assert tlcf.value_local_ccy is not None
+        assert pytest.approx(tlcf.value) == (tlcf.value_local_ccy * tlcf.fx_rate)

wbaccounting/tests/test_processors.py

@@ -0,0 +1,28 @@
+import pytest
+
+
+@pytest.mark.django_db
+def test_dummy_processor(invoice, mocker):
+    from wbaccounting.processors import dummy_processor
+
+    invoice_type = invoice.invoice_type
+    invoice_type.processor = "wbaccounting.processors.dummy_processor.processor"
+    invoice_type.save()
+    invoice.status = invoice.Status.SUBMITTED
+    invoice.save()
+
+    dummy_processor = mocker.spy(dummy_processor, "processor")
+    invoice.approve()
+    invoice.save()
+    dummy_processor.assert_called_once()
+    assert invoice.status == invoice.Status.SENT
+
+
+@pytest.mark.django_db
+def test_no_processor(invoice):
+    invoice.status = invoice.Status.SUBMITTED
+    invoice.save()
+
+    invoice.approve()
+    invoice.save()
+    assert invoice.status == invoice.Status.APPROVED

wbaccounting/tests/test_serializers/test_booking_entries.py

@@ -0,0 +1,69 @@
+import factory
+import pytest
+from django.test import RequestFactory
+from rest_framework.reverse import reverse
+from wbaccounting.models import BookingEntry
+from wbaccounting.serializers import (
+    BookingEntryModelSerializer,
+    BookingEntryRepresentationSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestBookingEntryModelSerializer:
+    def test_serialize(self, booking_entry: BookingEntry):
+        serializer = BookingEntryModelSerializer(booking_entry)
+        assert isinstance(serializer.data, dict)
+
+    def test_serialize_contains_keys(self, booking_entry: BookingEntry):
+        serializer = BookingEntryModelSerializer(booking_entry)
+        assert (
+            "id",
+            "title",
+            "booking_date",
+            "due_date",
+            "payment_date",
+            "reference_date",
+            "net_value",
+            "gross_value",
+            "vat",
+            "invoice_net_value",
+            "invoice_gross_value",
+            "invoice_fx_rate",
+            "currency",
+            "_currency",
+            "counterparty",
+            "_counterparty",
+            "invoice",
+            "_invoice",
+            "invoice_currency",
+            "_additional_resources",
+            "_buttons",
+        ) == tuple(
+            serializer.data.keys()
+        )  # type: ignore
+
+    @pytest.mark.parametrize("decorator", ["net_value", "gross_value"])
+    def test_serialize_decorators(self, booking_entry: BookingEntry, rf: RequestFactory, decorator: str):
+        serializer = BookingEntryModelSerializer(booking_entry)
+        _, representation = serializer[decorator].get_representation(rf.get("/"), decorator)  # type: ignore
+        assert representation["decorators"] == [{"position": "left", "type": "text", "value": "{{_currency.symbol}}"}]
+
+    def test_deserialize(self, booking_entry_factory, entry, currency, invoice):
+        data = factory.build(dict, FACTORY_CLASS=booking_entry_factory)
+        data["currency"] = currency.pk
+        data["counterparty"] = entry.pk
+        data["invoice"] = invoice.pk
+        serializer = BookingEntryModelSerializer(data=data)
+        assert serializer.is_valid()
+
+
+@pytest.mark.django_db
+class TestBookingEntryRepresentationSerializer:
+    def test_serialize(self, booking_entry: BookingEntry):
+        serializer = BookingEntryRepresentationSerializer(booking_entry)
+        assert serializer.data == {
+            "id": booking_entry.pk,
+            "title": booking_entry.title,
+            "_detail": reverse("wbaccounting:bookingentry-detail", args=[booking_entry.pk]),
+        }

wbaccounting/tests/test_serializers/test_entry_accounting_information.py

@@ -0,0 +1,64 @@
+import factory
+import pytest
+from wbaccounting.models import EntryAccountingInformation
+from wbaccounting.serializers import (
+    EntryAccountingInformationModelSerializer,
+    EntryAccountingInformationRepresentationSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestEntryAccountingInformationModelSerializer:
+    def test_serialize(self, entry_accounting_information: EntryAccountingInformation):
+        serializer = EntryAccountingInformationModelSerializer(entry_accounting_information)
+        assert isinstance(serializer.data, dict)
+
+    #
+    def test_serialize_contains_keys(self, entry_accounting_information: EntryAccountingInformation):
+        serializer = EntryAccountingInformationModelSerializer(entry_accounting_information)
+        assert (
+            "id",
+            "entry",
+            "_entry",
+            "tax_id",
+            "vat",
+            "default_currency",
+            "_default_currency",
+            "default_invoice_type",
+            "_default_invoice_type",
+            "email_to",
+            "email_cc",
+            "email_bcc",
+            "_email_to",
+            "_email_cc",
+            "_email_bcc",
+            "email_subject",
+            "email_body",
+            "send_mail",
+            "counterparty_is_private",
+            "exempt_users",
+            "_exempt_users",
+            "booking_entry_generator",
+            "external_invoice_users",
+            "_external_invoice_users",
+            "_additional_resources",
+        ) == tuple(
+            serializer.data.keys()
+        )  # type: ignore
+
+    def test_deserialize(self, entry_accounting_information_factory, entry, currency):
+        data = factory.build(dict, FACTORY_CLASS=entry_accounting_information_factory)
+        data["entry"] = entry.pk
+        data["default_currency"] = currency.pk
+        serializer = EntryAccountingInformationModelSerializer(data=data)
+        assert serializer.is_valid()
+
+
+@pytest.mark.django_db
+class TestEntryAccountingInformationRepresentationSerializer:
+    def test_serialize(self, entry_accounting_information: EntryAccountingInformation):
+        serializer = EntryAccountingInformationRepresentationSerializer(entry_accounting_information)
+        assert serializer.data == {
+            "id": entry_accounting_information.pk,
+            "entry_repr": entry_accounting_information.entry.computed_str,
+        }

wbaccounting/tests/test_serializers/test_invoice_types.py

@@ -0,0 +1,35 @@
+import factory
+import pytest
+from rest_framework.reverse import reverse
+from wbaccounting.models import InvoiceType
+from wbaccounting.serializers import (
+    InvoiceTypeModelSerializer,
+    InvoiceTypeRepresentationSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestInvoiceTypeModelSerializer:
+    def test_serialize(self, invoice_type: InvoiceType):
+        serializer = InvoiceTypeModelSerializer(invoice_type)
+        assert serializer.data == {
+            "id": invoice_type.pk,
+            "name": invoice_type.name,
+            "processor": invoice_type.processor,
+        }
+
+    def test_deserialize(self, invoice_type_factory):
+        data = factory.build(dict, FACTORY_CLASS=invoice_type_factory)
+        serializer = InvoiceTypeModelSerializer(data=data)
+        assert serializer.is_valid()
+
+
+@pytest.mark.django_db
+class TestInvoiceTypeRepresentationSerializer:
+    def test_serialize(self, invoice_type: InvoiceType):
+        serializer = InvoiceTypeRepresentationSerializer(invoice_type)
+        assert serializer.data == {
+            "id": invoice_type.pk,
+            "name": invoice_type.name,
+            "_detail": reverse("wbaccounting:invoicetype-detail", args=[invoice_type.pk]),
+        }