Verbeter mijn unit test refactoring en optimalisatie
description
Met deze prompt ontvang je gerichte hulp om je unit tests overzichtelijker en onderhoudsvriendelijker te maken, wat de kwaliteit van je test suite verhoogt en toekomstige fouten voorkomt. Het helpt je dubbele code te vermijden en maakt het makkelijker om tests aan te passen bij codewijzigingen.
prompt
Help me mijn bestaande unit tests te refactoren en te optimaliseren voor betere leesbaarheid en onderhoudbaarheid. Mijn huidige testcode: <voeg hier je huidige unit testcode in>. Geef c ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier zijn enkele concrete adviezen en voorbeelden om je tests te herstructureren, hergebruiken en verbeteren, inclusief relevante refactoring technieken en best practices:
---
### 1. **Gebruik van setUp() en tearDown() voor gedeelde setup**
Als je tests gedeelde setup of initialisatie hebben, verplaats die dan naar `setUp()` om herhaling te voorkomen.
**Voorbeeld:**
```python
import unittest
class TestExample(unittest.TestCase):
def setUp(self):
# Voorbeeld van gedeelde setup
self.test_value = True
def test_true(self):
self.assertTrue(self.test_value)
```
---
### 2. **Gebruik van helper-methodes voor herhaalde assertions**
Maak helper-methodes voor assertions die je vaak gebruikt, om de tests overzichtelijker te maken en DRY te blijven.
**Voorbeeld:**
```python
import unittest
class TestExample(unittest.TestCase):
def assertIsPositive(self, value):
self.assertGreater(value, 0, f"{value} moet positief zijn")
def test_positive_value(self):
self.assertIsPositive(5)
def test_negative_value(self):
with self.assertRaises(AssertionError):
self.assertIsPositive(-3)
```
---
### 3. **Gebruik van parameterized tests voor verschillende inputs**
Gebruik libraries zoals `parameterized` of `unittest`'s eigen `subTest()` om meerdere invoerwaarden te testen binnen één test.
**Voorbeeld met `subTest()`:**
```python
import unittest
class TestExample(unittest.TestCase):
def test_multiple_values(self):
for value in [1, 2, 3, 4]:
with self.subTest(value=value):
self.assertTrue(value > 0)
```
---
### 4. **Structureren van tests per functionaliteit**
Verdeel tests in meerdere klassen en modules gebaseerd op functionaliteit of gedrag, zodat tests overzichtelijk blijven.
**Voorbeeld:**
```python
import unittest
class TestMathOperations(unittest.TestCase):
def test_addition(self):
self.assertEqual(1 + 1, 2)
def test_subtraction(self):
self.assertEqual(5 - 3, 2)
class TestStringMethods(unittest.TestCase):
def test_upper(self):
self.assertEqual('foo'.upper(), 'FOO')
```
---
### 5. **Gebruik van duidelijke naamgeving en documentatie**
Gebruik beschrijvende naamgeving voor testmethodes en voeg commentaar of docstrings toe voor extra uitleg.
**Voorbeeld:**
```python
import unittest
class TestUserAuthentication(unittest.TestCase):
def test_login_with_valid_credentials(self):
"""Test succesvolle login met juiste gegevens"""
# testcode hier
pass
def test_login_with_invalid_credentials(self):
"""Test mislukte login met onjuiste gegevens"""
# testcode hier
pass
```
---
### 6. **Refactoring technieken**
- **Extract Method:** Verplaats complexe setup of assertions naar aparte methodes.
- **Parameterization:** Vermijd dubbele code door invoerwaarden te parametriseren.
- **Test Data Builders:** Gebruik objecten of data-structuren om testdata te genereren, vooral bij complexe objecten.
---
### 7. **Best practices**
- **Wees zo specifiek mogelijk:** Elke test moet één gedrag controleren.
- **Zorg voor onafhankelijke tests:** Tests mogen niet afhankelijk van elkaar.
- **Gebruik mocks en stubs waar nodig:** Om afhankelijkheden te isoleren.
- **Maak tests snel en betrouwbaar:** Vermijd complexe setup die veel tijd kost.
---
### Samenvatting
Door deze technieken toe te passen, wordt je testcode:
- Leesbaarder
- Onderhoudsvriendelijker
- Minder duplication
- Betere structuur en overzicht
---
Wil je dat ik een voorbeeld van je volledige code herstructureer?
provider: deepseek
model: deepseek-chat
Hier zijn concrete refactoringtechnieken en best practices voor uw unit tests:
## 1. Betere Teststructuur met Setup/TearDown
```python
import unittest
class TestExample(unittest.TestCase):
def setUp(self):
# Gemeenschappelijke setup voor alle tests
self.test_data = {"key": "value"}
self.expected_result = True
def tearDown(self):
# Opruimen na elke test
self.test_data = None
def test_should_return_true_when_condition_met(self):
# Arrange
expected = self.expected_result
# Act
result = True
# Assert
self.assertTrue(result)
```
## 2. Gebruik van Helper Methods
```python
class TestExample(unittest.TestCase):
def create_test_user(self, name="test_user", age=25):
return {"name": name, "age": age}
def assert_user_valid(self, user):
self.assertIsInstance(user, dict)
self.assertIn("name", user)
self.assertIn("age", user)
self.assertGreater(user["age"], 0)
def test_user_creation(self):
user = self.create_test_user()
self.assert_user_valid(user)
```
## 3. Parametrische Tests (gebruik parameterized)
```python
# Eerst: pip install parameterized
from parameterized import parameterized
class TestMathOperations(unittest.TestCase):
@parameterized.expand([
(2, 2, 4),
(3, 3, 9),
(0, 5, 0),
(-2, 2, -4)
])
def test_multiply_numbers(self, a, b, expected):
result = a * b
self.assertEqual(result, expected)
```
## 4. Duidelijke Testnamen
```python
class TestStringOperations(unittest.TestCase):
def test_should_return_uppercase_string_when_lowercase_input_given(self):
input_str = "hello"
result = input_str.upper()
self.assertEqual(result, "HELLO")
def test_should_raise_value_error_when_empty_string_provided(self):
with self.assertRaises(ValueError):
int("")
```
## 5. Gebruik van Context Managers
```python
class TestFileOperations(unittest.TestCase):
def test_should_create_file_with_correct_content(self):
test_content = "Hello World"
with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
tmp.write(test_content)
tmp_path = tmp.name
try:
with open(tmp_path, 'r') as f:
content = f.read()
self.assertEqual(content, test_content)
finally:
os.unlink(tmp_path)
```
## 6. Test Fixtures voor Complexe Setup
```python
class TestDatabaseOperations(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.db_connection = create_test_database()
cls.setup_test_data()
@classmethod
def tearDownClass(cls):
cls.db_connection.close()
def test_should_retrieve_user_by_id(self):
user = self.db_connection.get_user(1)
self.assertIsNotNone(user)
self.assertEqual(user.id, 1)
```
## 7. Gebruik van Mock Objects
```python
from unittest.mock import Mock, patch
class TestExternalService(unittest.TestCase):
@patch('requests.get')
def test_should_handle_api_response_correctly(self, mock_get):
# Arrange
mock_response = Mock()
mock_response.json.return_value = {"status": "success"}
mock_get.return_value = mock_response
# Act
result = fetch_data_from_api()
# Assert
self.assertEqual(result["status"], "success")
mock_get.assert_called_once()
```
## Best Practices:
1. **Eén assert per test** (focus op één gedrag)
2. **Descriptieve testnamen** die het verwachte gedrag beschrijven
3. **AAA-patroon**: Arrange-Act-Assert
4. **Geen magische getallen** - gebruik betekenisvolle constanten
5. **Onafhankelijke tests** - elke test moet in isolatie werken
6. **Snelle tests** - vermijd I/O-operaties waar mogelijk
## Uw refactored voorbeeld:
```python
import unittest
class TestBooleanOperations(unittest.TestCase):
def test_should_return_true_when_boolean_true_provided(self):
# Arrange
test_value = True
# Act & Assert
self.assertTrue(test_value)
def test_should_return_false_when_boolean_false_provided(self):
# Arrange
test_value = False
# Act & Assert
self.assertFalse(test_value)
```
Deze technieken verbeteren leesbaarheid, onderhoudbaarheid en maken tests minder fragiel.