365 lines
13 KiB
Python
365 lines
13 KiB
Python
"""
|
|
Tests unitaires pour les paramètres d'unicité des documents.
|
|
|
|
Ces tests vérifient que le système de versioning fonctionne correctement
|
|
avec les paramètres d'unicité.
|
|
"""
|
|
|
|
from django.test import TestCase
|
|
from django.contrib.auth import get_user_model
|
|
from documents.models import DocumentFolder, DocumentTag, ManagedDocument
|
|
from documents.services import DocumentManagementService
|
|
from io import BytesIO
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
|
|
User = get_user_model()
|
|
|
|
|
|
class UniqueParamsTestCase(TestCase):
|
|
"""Tests pour les paramètres d'unicité des documents."""
|
|
|
|
def setUp(self):
|
|
"""Initialisation des données de test."""
|
|
self.user = User.objects.create_user(
|
|
username='testuser',
|
|
password='testpass123'
|
|
)
|
|
|
|
# Créer un dossier de test
|
|
self.folder = DocumentFolder.objects.create(
|
|
name='Test Folder',
|
|
slug='test-folder',
|
|
)
|
|
|
|
# Créer un tag unique
|
|
self.unique_tag = DocumentTag.objects.create(
|
|
name_fr='As-Built',
|
|
slug='asbuilt',
|
|
is_unique=True,
|
|
)
|
|
|
|
# Créer un tag non-unique
|
|
self.regular_tag = DocumentTag.objects.create(
|
|
name_fr='Photo',
|
|
slug='photo',
|
|
is_unique=False,
|
|
)
|
|
|
|
def create_test_file(self, filename='test.pdf', content=b'test content'):
|
|
"""Crée un fichier de test."""
|
|
return SimpleUploadedFile(filename, content)
|
|
|
|
def test_same_tag_different_params_creates_different_documents(self):
|
|
"""
|
|
Test: Deux documents avec le même tag mais des paramètres différents
|
|
doivent créer deux documents distincts.
|
|
"""
|
|
# Premier document: as-built format PDF
|
|
file1 = self.create_test_file('asbuilt_v1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built PDF',
|
|
unique_params={'format': 'pdf'}
|
|
)
|
|
|
|
# Deuxième document: as-built format DXF
|
|
file2 = self.create_test_file('asbuilt_v1.dxf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built DXF',
|
|
unique_params={'format': 'dxf'}
|
|
)
|
|
|
|
# Vérifications
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertFalse(result2['is_new_version'])
|
|
self.assertNotEqual(result1['document'].id, result2['document'].id)
|
|
self.assertEqual(result1['document'].unique_params, {'format': 'pdf'})
|
|
self.assertEqual(result2['document'].unique_params, {'format': 'dxf'})
|
|
|
|
def test_same_tag_same_params_creates_version(self):
|
|
"""
|
|
Test: Deux documents avec le même tag et les mêmes paramètres
|
|
doivent créer une nouvelle version du même document.
|
|
"""
|
|
# Premier document
|
|
file1 = self.create_test_file('asbuilt_v1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built PDF v1',
|
|
unique_params={'format': 'pdf'}
|
|
)
|
|
|
|
# Deuxième document avec les mêmes paramètres
|
|
file2 = self.create_test_file('asbuilt_v2.pdf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built PDF v2',
|
|
unique_params={'format': 'pdf'}
|
|
)
|
|
|
|
# Vérifications
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertTrue(result2['is_new_version'])
|
|
self.assertEqual(result1['document'].id, result2['document'].id)
|
|
self.assertEqual(result2['document'].versions.count(), 2)
|
|
|
|
def test_empty_params_vs_no_params(self):
|
|
"""
|
|
Test: Un document sans paramètres ({}) et un document avec paramètres
|
|
doivent être considérés comme différents.
|
|
"""
|
|
# Premier document: sans paramètres
|
|
file1 = self.create_test_file('asbuilt1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built sans format',
|
|
unique_params={}
|
|
)
|
|
|
|
# Deuxième document: avec paramètres
|
|
file2 = self.create_test_file('asbuilt2.pdf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='As-Built PDF',
|
|
unique_params={'format': 'pdf'}
|
|
)
|
|
|
|
# Vérifications
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertFalse(result2['is_new_version'])
|
|
self.assertNotEqual(result1['document'].id, result2['document'].id)
|
|
self.assertEqual(result1['document'].unique_params, {})
|
|
self.assertEqual(result2['document'].unique_params, {'format': 'pdf'})
|
|
|
|
def test_multiple_params(self):
|
|
"""
|
|
Test: Documents avec plusieurs paramètres différents.
|
|
"""
|
|
# Document 1: câbles C1,C2
|
|
file1 = self.create_test_file('cross_plan_A.xlsx')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Cross Plan A',
|
|
unique_params={'cables': 'C1,C2', 'zone': 'A'}
|
|
)
|
|
|
|
# Document 2: câbles C3,C4 (zone différente)
|
|
file2 = self.create_test_file('cross_plan_B.xlsx')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Cross Plan B',
|
|
unique_params={'cables': 'C3,C4', 'zone': 'B'}
|
|
)
|
|
|
|
# Document 3: mêmes paramètres que document 1 (nouvelle version)
|
|
file3 = self.create_test_file('cross_plan_A_v2.xlsx')
|
|
result3 = DocumentManagementService.add_document(
|
|
file=file3,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Cross Plan A v2',
|
|
unique_params={'cables': 'C1,C2', 'zone': 'A'}
|
|
)
|
|
|
|
# Vérifications
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertFalse(result2['is_new_version'])
|
|
self.assertTrue(result3['is_new_version'])
|
|
self.assertNotEqual(result1['document'].id, result2['document'].id)
|
|
self.assertEqual(result1['document'].id, result3['document'].id)
|
|
|
|
def test_get_all_documents_by_tag(self):
|
|
"""
|
|
Test: Récupération de tous les documents avec un tag donné.
|
|
"""
|
|
# Créer plusieurs documents avec le même tag mais des paramètres différents
|
|
for i, fmt in enumerate(['pdf', 'dxf', 'dwg']):
|
|
file = self.create_test_file(f'asbuilt_{i}.{fmt}')
|
|
DocumentManagementService.add_document(
|
|
file=file,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title=f'As-Built {fmt.upper()}',
|
|
unique_params={'format': fmt}
|
|
)
|
|
|
|
# Mock content_object avec get_default_folder
|
|
class MockObject:
|
|
pass
|
|
|
|
mock_obj = MockObject()
|
|
|
|
# On ne peut pas vraiment tester get_all_documents_by_tag sans un vrai content_object
|
|
# mais on peut vérifier que les documents ont été créés correctement
|
|
docs = ManagedDocument.objects.filter(tags=self.unique_tag)
|
|
self.assertEqual(docs.count(), 3)
|
|
|
|
formats = [doc.unique_params.get('format') for doc in docs]
|
|
self.assertIn('pdf', formats)
|
|
self.assertIn('dxf', formats)
|
|
self.assertIn('dwg', formats)
|
|
|
|
def test_params_order_doesnt_matter(self):
|
|
"""
|
|
Test: L'ordre des paramètres ne doit pas affecter l'unicité.
|
|
"""
|
|
# Premier document
|
|
file1 = self.create_test_file('doc1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Doc 1',
|
|
unique_params={'format': 'pdf', 'language': 'fr'}
|
|
)
|
|
|
|
# Deuxième document avec les mêmes paramètres mais dans un ordre différent
|
|
file2 = self.create_test_file('doc2.pdf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Doc 2',
|
|
unique_params={'language': 'fr', 'format': 'pdf'}
|
|
)
|
|
|
|
# Vérifications: doit créer une nouvelle version, pas un nouveau document
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertTrue(result2['is_new_version'])
|
|
self.assertEqual(result1['document'].id, result2['document'].id)
|
|
|
|
def test_non_unique_tag_ignores_params(self):
|
|
"""
|
|
Test: Les tags non-uniques doivent toujours créer de nouveaux documents,
|
|
même avec les mêmes paramètres.
|
|
"""
|
|
# Premier document
|
|
file1 = self.create_test_file('photo1.jpg')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.regular_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Photo 1',
|
|
unique_params={'format': 'jpg'}
|
|
)
|
|
|
|
# Deuxième document avec les mêmes paramètres
|
|
file2 = self.create_test_file('photo2.jpg')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.regular_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
title='Photo 2',
|
|
unique_params={'format': 'jpg'}
|
|
)
|
|
|
|
# Vérifications: doit créer deux documents distincts
|
|
self.assertFalse(result1['is_new_version'])
|
|
self.assertFalse(result2['is_new_version'])
|
|
self.assertNotEqual(result1['document'].id, result2['document'].id)
|
|
|
|
|
|
class UniqueParamsEdgeCasesTestCase(TestCase):
|
|
"""Tests pour les cas limites et edge cases."""
|
|
|
|
def setUp(self):
|
|
"""Initialisation des données de test."""
|
|
self.user = User.objects.create_user(
|
|
username='testuser',
|
|
password='testpass123'
|
|
)
|
|
self.folder = DocumentFolder.objects.create(
|
|
name='Test Folder',
|
|
slug='test-folder',
|
|
)
|
|
self.unique_tag = DocumentTag.objects.create(
|
|
name_fr='Document',
|
|
slug='document',
|
|
is_unique=True,
|
|
)
|
|
|
|
def create_test_file(self, filename='test.pdf', content=b'test content'):
|
|
"""Crée un fichier de test."""
|
|
return SimpleUploadedFile(filename, content)
|
|
|
|
def test_case_sensitive_params(self):
|
|
"""
|
|
Test: Les paramètres sont sensibles à la casse.
|
|
"""
|
|
file1 = self.create_test_file('doc1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
unique_params={'format': 'pdf'}
|
|
)
|
|
|
|
file2 = self.create_test_file('doc2.pdf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
unique_params={'format': 'PDF'} # Majuscules
|
|
)
|
|
|
|
# Doit créer deux documents différents car 'pdf' != 'PDF'
|
|
self.assertNotEqual(result1['document'].id, result2['document'].id)
|
|
|
|
def test_nested_params_not_recommended(self):
|
|
"""
|
|
Test: Les paramètres imbriqués fonctionnent mais ne sont pas recommandés.
|
|
"""
|
|
file1 = self.create_test_file('doc1.pdf')
|
|
result1 = DocumentManagementService.add_document(
|
|
file=file1,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
unique_params={'metadata': {'format': 'pdf', 'size': 'A4'}}
|
|
)
|
|
|
|
file2 = self.create_test_file('doc2.pdf')
|
|
result2 = DocumentManagementService.add_document(
|
|
file=file2,
|
|
tag=self.unique_tag,
|
|
folder=self.folder,
|
|
user=self.user,
|
|
unique_params={'metadata': {'format': 'pdf', 'size': 'A4'}}
|
|
)
|
|
|
|
# Doit créer une nouvelle version
|
|
self.assertTrue(result2['is_new_version'])
|
|
self.assertEqual(result1['document'].id, result2['document'].id)
|