Pular para conteúdo

Test finances transaction serializer

TransactionSerializerTestCase

Bases: TestCase

Testes para o serializador de Transação.

Esta classe contém testes para o serializador de Transaction, que é responsável por validar e transformar dados de transações financeiras em um formato adequado para o uso na API.

Source code in finances/tests/test_finances_transaction_serializer.py 
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
class TransactionSerializerTestCase(TestCase):
    """
    Testes para o serializador de Transação.

    Esta classe contém testes para o serializador de Transaction, que é
    responsável por validar e transformar dados de transações financeiras em um
    formato adequado para o uso na API.
    """

    def setUp(self):
        """
        Configuração inicial para os testes.

        Este método é executado antes de cada teste. Ele cria instâncias
        iniciais de objetos necessários para os testes.
        """

        self.user = User.objects.create_user(
            username='user1',
            password='password1',
            first_name='Carlos',
            last_name='Alberto',
            email='carlos@email.com'
        )

        self.account = Account.objects.create(
            owner=self.user,
            name='Conta Corrente',
            balance=1000
        )

        self.category_1 = Category.objects.create(
            name='Academia'
        )

        self.category_2 = Category.objects.create(
            name="Medicamentos"
        )

        self.transaction_data = {
            'amount': 30,
            'description': 'Test Transaction',
            'account': self.account.pk,
            'category': self.category_1.pk
        }

        self.serializer = TransactionSerializer()

    def test_amount_required(self):
        """
        Testa a necessidade de uma quantia.

        Este teste verifica se o serializador valida corretamente a presença de
        uma quantia e lança um erro se ela estiver ausente.
        """

        with self.assertRaises(ValidationError) as context:
            data = {'description': 'Test', 'account': 'acc', 'category': 'cat'}
            TransactionSerializer().validate(data)
        self.assertTrue('amount' in context.exception.detail)

    def test_description_required(self):
        """
        Testa a necessidade de uma descrição.

        Este teste verifica se o serializador valida corretamente a presença de
        uma descrição e lança um erro se ela estiver ausente.
        """

        with self.assertRaises(ValidationError) as context:
            data = {'amount': 100, 'account': 'acc', 'category': 'cat'}
            TransactionSerializer().validate(data)
        self.assertTrue('description' in context.exception.detail)

    def test_account_required(self):
        """
        Testa a necessidade de uma conta.

        Este teste verifica se o serializador valida corretamente a presença de
        uma conta e lança um erro se ela estiver ausente.
        """

        with self.assertRaises(ValidationError) as context:
            data = {'amount': 100, 'description': 'Test', 'category': 'cat'}
            TransactionSerializer().validate(data)
        self.assertTrue('account' in context.exception.detail)

    def test_category_required(self):
        """
        Testa a necessidade de uma categoria.

        Este teste verifica se o serializador valida corretamente a presença de
        uma categoria e lança um erro se ela estiver ausente.
        """

        with self.assertRaises(ValidationError) as context:
            data = {'amount': 100, 'description': 'Test', 'account': 'acc'}
            TransactionSerializer().validate(data)
        self.assertTrue('category' in context.exception.detail)

    def test_insufficient_balance(self):
        """
        Testa o saldo insuficiente.

        Este teste verifica se o serializador valida corretamente um saldo
        insuficiente e lança um erro apropriado.
        """

        data = {
            'amount': 500,
            'description': 'Test',
            'account': {'balance': 200},
            'category': 'cat'

        }

        serializer = TransactionSerializer()
        account = data['account']
        account_obj = Account.objects.create(balance=account['balance'])
        data['account'] = account_obj

        with self.assertRaises(ValidationError) as context:
            serializer.validate(data)
        self.assertTrue(
            'Insufficient balance for the transaction.' in
            str(context.exception)
        )

    def test_create_method(self):
        """
        Testa o método de criação.

        Este teste verifica se o método de criação do serializador cria
        corretamente uma nova transação com os dados fornecidos.
        """

        serializer = TransactionSerializer(data=self.transaction_data)
        serializer.is_valid(raise_exception=True)
        transaction = serializer.save()
        self.assertEqual(transaction.amount, self.transaction_data['amount'])

        self.account.refresh_from_db()
        self.assertEqual(self.account.balance, 970)

    def test_create_method_exceeds_budget(self):
        """
        Testa o método de criação que excede o orçamento.

        Este teste verifica se o método de criação do serializador lança um
        erro ao tentar exceder o orçamento permitido.
        """

        budget = Budget.objects.create(  # noqa: 841
            start_date='2023-08-01',
            end_date='2023-08-31',
            amount=100,
            account=self.account,
            category=self.category_1
        )

        transaction_data_exceeds_budget = {
            'amount': 150,
            'description': 'Exceeding Transaction',
            'account': self.account.pk,
            'category': self.category_1.pk
        }

        serializer = TransactionSerializer(
            data=transaction_data_exceeds_budget
        )

        with self.assertRaises(ValidationError) as context:
            serializer.is_valid(raise_exception=True)

        errors = context.exception.detail
        message = 'The value of the transaction exceeds the \
budget for this category.'
        self.assertIn(
            message,
            errors.get('non_field_errors', [''])
        )

    def test_update_transaction(self):
        """
        Testa o método de atualização de transação.

        Este teste verifica se o método de atualização do serializador atualiza
        corretamente uma transação com os novos dados fornecidos.
        """

        account = Account.objects.create(balance=1000)
        category = Category.objects.create(
            name='Test Category')
        budget = Budget.objects.create(
            account=account,
            category=category,
            amount=500,
            start_date='2023-01-01',
            end_date='2023-01-31'
        )

        transaction_data = {
            'amount': 200,
            'description': 'Initial transaction',
            'account': account,
            'category': category
        }

        transaction = Transaction.objects.create(**transaction_data)

        serializer = TransactionSerializer()
        updated_transaction_data = {
            'amount': 300,
            'description': 'Updated transaction',
            'category': category
        }

        serializer.update(transaction, updated_transaction_data)

        updated_transaction = Transaction.objects.get(pk=transaction.id)
        self.assertEqual(updated_transaction.amount, 300)
        self.assertEqual(
            updated_transaction.description,
            'Updated transaction'
        )

        updated_budget = Budget.objects.get(pk=budget.id)
        self.assertEqual(updated_budget.spent, 300 - 200)

        updated_account = Account.objects.get(pk=account.id)
        self.assertEqual(updated_account.balance, 1000)

setUp()

Configuração inicial para os testes.

Este método é executado antes de cada teste. Ele cria instâncias iniciais de objetos necessários para os testes.

Source code in finances/tests/test_finances_transaction_serializer.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def setUp(self):
    """
    Configuração inicial para os testes.

    Este método é executado antes de cada teste. Ele cria instâncias
    iniciais de objetos necessários para os testes.
    """

    self.user = User.objects.create_user(
        username='user1',
        password='password1',
        first_name='Carlos',
        last_name='Alberto',
        email='carlos@email.com'
    )

    self.account = Account.objects.create(
        owner=self.user,
        name='Conta Corrente',
        balance=1000
    )

    self.category_1 = Category.objects.create(
        name='Academia'
    )

    self.category_2 = Category.objects.create(
        name="Medicamentos"
    )

    self.transaction_data = {
        'amount': 30,
        'description': 'Test Transaction',
        'account': self.account.pk,
        'category': self.category_1.pk
    }

    self.serializer = TransactionSerializer()

test_account_required()

Testa a necessidade de uma conta.

Este teste verifica se o serializador valida corretamente a presença de uma conta e lança um erro se ela estiver ausente.

Source code in finances/tests/test_finances_transaction_serializer.py 
82
83
84
85
86
87
88
89
90
91
92
93
def test_account_required(self):
    """
    Testa a necessidade de uma conta.

    Este teste verifica se o serializador valida corretamente a presença de
    uma conta e lança um erro se ela estiver ausente.
    """

    with self.assertRaises(ValidationError) as context:
        data = {'amount': 100, 'description': 'Test', 'category': 'cat'}
        TransactionSerializer().validate(data)
    self.assertTrue('account' in context.exception.detail)

test_amount_required()

Testa a necessidade de uma quantia.

Este teste verifica se o serializador valida corretamente a presença de uma quantia e lança um erro se ela estiver ausente.

Source code in finances/tests/test_finances_transaction_serializer.py 
56
57
58
59
60
61
62
63
64
65
66
67
def test_amount_required(self):
    """
    Testa a necessidade de uma quantia.

    Este teste verifica se o serializador valida corretamente a presença de
    uma quantia e lança um erro se ela estiver ausente.
    """

    with self.assertRaises(ValidationError) as context:
        data = {'description': 'Test', 'account': 'acc', 'category': 'cat'}
        TransactionSerializer().validate(data)
    self.assertTrue('amount' in context.exception.detail)

test_category_required()

Testa a necessidade de uma categoria.

Este teste verifica se o serializador valida corretamente a presença de uma categoria e lança um erro se ela estiver ausente.

Source code in finances/tests/test_finances_transaction_serializer.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def test_category_required(self):
    """
    Testa a necessidade de uma categoria.

    Este teste verifica se o serializador valida corretamente a presença de
    uma categoria e lança um erro se ela estiver ausente.
    """

    with self.assertRaises(ValidationError) as context:
        data = {'amount': 100, 'description': 'Test', 'account': 'acc'}
        TransactionSerializer().validate(data)
    self.assertTrue('category' in context.exception.detail)

test_create_method()

Testa o método de criação.

Este teste verifica se o método de criação do serializador cria corretamente uma nova transação com os dados fornecidos.

Source code in finances/tests/test_finances_transaction_serializer.py 
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
def test_create_method(self):
    """
    Testa o método de criação.

    Este teste verifica se o método de criação do serializador cria
    corretamente uma nova transação com os dados fornecidos.
    """

    serializer = TransactionSerializer(data=self.transaction_data)
    serializer.is_valid(raise_exception=True)
    transaction = serializer.save()
    self.assertEqual(transaction.amount, self.transaction_data['amount'])

    self.account.refresh_from_db()
    self.assertEqual(self.account.balance, 970)

test_create_method_exceeds_budget()

Testa o método de criação que excede o orçamento.

Este teste verifica se o método de criação do serializador lança um erro ao tentar exceder o orçamento permitido.

Source code in finances/tests/test_finances_transaction_serializer.py 
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
    def test_create_method_exceeds_budget(self):
        """
        Testa o método de criação que excede o orçamento.

        Este teste verifica se o método de criação do serializador lança um
        erro ao tentar exceder o orçamento permitido.
        """

        budget = Budget.objects.create(  # noqa: 841
            start_date='2023-08-01',
            end_date='2023-08-31',
            amount=100,
            account=self.account,
            category=self.category_1
        )

        transaction_data_exceeds_budget = {
            'amount': 150,
            'description': 'Exceeding Transaction',
            'account': self.account.pk,
            'category': self.category_1.pk
        }

        serializer = TransactionSerializer(
            data=transaction_data_exceeds_budget
        )

        with self.assertRaises(ValidationError) as context:
            serializer.is_valid(raise_exception=True)

        errors = context.exception.detail
        message = 'The value of the transaction exceeds the \
budget for this category.'
        self.assertIn(
            message,
            errors.get('non_field_errors', [''])
        )

test_description_required()

Testa a necessidade de uma descrição.

Este teste verifica se o serializador valida corretamente a presença de uma descrição e lança um erro se ela estiver ausente.

Source code in finances/tests/test_finances_transaction_serializer.py 
69
70
71
72
73
74
75
76
77
78
79
80
def test_description_required(self):
    """
    Testa a necessidade de uma descrição.

    Este teste verifica se o serializador valida corretamente a presença de
    uma descrição e lança um erro se ela estiver ausente.
    """

    with self.assertRaises(ValidationError) as context:
        data = {'amount': 100, 'account': 'acc', 'category': 'cat'}
        TransactionSerializer().validate(data)
    self.assertTrue('description' in context.exception.detail)

test_insufficient_balance()

Testa o saldo insuficiente.

Este teste verifica se o serializador valida corretamente um saldo insuficiente e lança um erro apropriado.

Source code in finances/tests/test_finances_transaction_serializer.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
def test_insufficient_balance(self):
    """
    Testa o saldo insuficiente.

    Este teste verifica se o serializador valida corretamente um saldo
    insuficiente e lança um erro apropriado.
    """

    data = {
        'amount': 500,
        'description': 'Test',
        'account': {'balance': 200},
        'category': 'cat'

    }

    serializer = TransactionSerializer()
    account = data['account']
    account_obj = Account.objects.create(balance=account['balance'])
    data['account'] = account_obj

    with self.assertRaises(ValidationError) as context:
        serializer.validate(data)
    self.assertTrue(
        'Insufficient balance for the transaction.' in
        str(context.exception)
    )

test_update_transaction()

Testa o método de atualização de transação.

Este teste verifica se o método de atualização do serializador atualiza corretamente uma transação com os novos dados fornecidos.

Source code in finances/tests/test_finances_transaction_serializer.py 
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
def test_update_transaction(self):
    """
    Testa o método de atualização de transação.

    Este teste verifica se o método de atualização do serializador atualiza
    corretamente uma transação com os novos dados fornecidos.
    """

    account = Account.objects.create(balance=1000)
    category = Category.objects.create(
        name='Test Category')
    budget = Budget.objects.create(
        account=account,
        category=category,
        amount=500,
        start_date='2023-01-01',
        end_date='2023-01-31'
    )

    transaction_data = {
        'amount': 200,
        'description': 'Initial transaction',
        'account': account,
        'category': category
    }

    transaction = Transaction.objects.create(**transaction_data)

    serializer = TransactionSerializer()
    updated_transaction_data = {
        'amount': 300,
        'description': 'Updated transaction',
        'category': category
    }

    serializer.update(transaction, updated_transaction_data)

    updated_transaction = Transaction.objects.get(pk=transaction.id)
    self.assertEqual(updated_transaction.amount, 300)
    self.assertEqual(
        updated_transaction.description,
        'Updated transaction'
    )

    updated_budget = Budget.objects.get(pk=budget.id)
    self.assertEqual(updated_budget.spent, 300 - 200)

    updated_account = Account.objects.get(pk=account.id)
    self.assertEqual(updated_account.balance, 1000)