267 lines
9.5 KiB
Python
267 lines
9.5 KiB
Python
from django.test import TestCase
|
|
from django.core.exceptions import ValidationError
|
|
from apps.domains.models import Domain, Organisation, Dataset
|
|
from apps.users.models import User
|
|
from uuid import uuid4
|
|
|
|
|
|
class DomainTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
self.domain1 = Domain.objects.create(name="Python", description="Python Programming")
|
|
self.domain2 = Domain.objects.create(name="JavaScript", description="JavaScript Development")
|
|
|
|
def test_domain_creation(self):
|
|
self.assertEqual(self.domain1.name, "Python")
|
|
self.assertEqual(self.domain2.name, "JavaScript")
|
|
|
|
def test_domain_string_representation(self):
|
|
self.assertEqual(str(self.domain1), "Python")
|
|
self.assertEqual(str(self.domain2), "JavaScript")
|
|
|
|
def test_domain_name_unique(self):
|
|
with self.assertRaises(Exception):
|
|
Domain.objects.create(name="Python", description="Duplicate")
|
|
|
|
def test_domain_description_blank(self):
|
|
domain = Domain.objects.create(name="Java")
|
|
self.assertEqual(domain.description, "")
|
|
|
|
def test_domain_description_optional(self):
|
|
domain = Domain.objects.create(name="Rust", description="System Programming")
|
|
self.assertIsNotNone(domain.description)
|
|
|
|
def test_domain_uuid_generated(self):
|
|
self.assertIsNotNone(self.domain1.uuid)
|
|
self.assertIsNotNone(self.domain2.uuid)
|
|
|
|
def test_domain_uuid_unique(self):
|
|
uuid1 = self.domain1.uuid
|
|
uuid2 = self.domain2.uuid
|
|
self.assertNotEqual(uuid1, uuid2)
|
|
|
|
def test_domain_uuid_immutable(self):
|
|
original_uuid = self.domain1.uuid
|
|
self.domain1.save()
|
|
self.assertEqual(self.domain1.uuid, original_uuid)
|
|
|
|
def test_domain_count(self):
|
|
self.assertEqual(Domain.objects.count(), 2)
|
|
|
|
def test_domain_filter_by_name(self):
|
|
domain = Domain.objects.get(name="Python")
|
|
self.assertEqual(domain.id, self.domain1.id)
|
|
|
|
def test_domain_filter_by_uuid(self):
|
|
domain = Domain.objects.get(uuid=self.domain1.uuid)
|
|
self.assertEqual(domain.name, "Python")
|
|
|
|
def test_domain_update_name(self):
|
|
self.domain1.name = "Python3"
|
|
self.domain1.save()
|
|
updated = Domain.objects.get(id=self.domain1.id)
|
|
self.assertEqual(updated.name, "Python3")
|
|
|
|
def test_domain_update_description(self):
|
|
self.domain1.description = "Advanced Python"
|
|
self.domain1.save()
|
|
updated = Domain.objects.get(id=self.domain1.id)
|
|
self.assertEqual(updated.description, "Advanced Python")
|
|
|
|
def test_domain_delete(self):
|
|
domain_id = self.domain1.id
|
|
self.domain1.delete()
|
|
with self.assertRaises(Domain.DoesNotExist):
|
|
Domain.objects.get(id=domain_id)
|
|
|
|
def test_domain_all_fields(self):
|
|
self.assertTrue(hasattr(self.domain1, 'name'))
|
|
self.assertTrue(hasattr(self.domain1, 'uuid'))
|
|
self.assertTrue(hasattr(self.domain1, 'description'))
|
|
|
|
def test_domain_max_length_name(self):
|
|
long_name = "a" * 255
|
|
domain = Domain.objects.create(name=long_name)
|
|
self.assertEqual(domain.name, long_name)
|
|
|
|
def test_domain_default_description(self):
|
|
domain = Domain.objects.create(name="Go")
|
|
self.assertEqual(domain.description, "")
|
|
|
|
|
|
class OrganisationTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
self.user1 = User.objects.create_user(email_address="manager@test.com", password="pass123")
|
|
self.user2 = User.objects.create_user(email_address="employee@test.com", password="pass123")
|
|
self.domain = Domain.objects.create(name="Technology")
|
|
# Organization model uses `owner` and `members`.
|
|
self.org1 = Organisation.objects.create(
|
|
name="TechCorp",
|
|
owner=self.user1,
|
|
)
|
|
# add member and link domain
|
|
self.org1.members.add(self.user2)
|
|
self.domain.organization = self.org1
|
|
self.domain.save()
|
|
|
|
def test_organisation_creation(self):
|
|
self.assertEqual(self.org1.name, "TechCorp")
|
|
|
|
def test_organisation_string_representation(self):
|
|
self.assertEqual(str(self.org1), "TechCorp")
|
|
|
|
def test_organisation_name_unique(self):
|
|
with self.assertRaises(Exception):
|
|
Organisation.objects.create(
|
|
name="TechCorp",
|
|
owner=self.user1,
|
|
)
|
|
|
|
def test_organisation_manager_relationship(self):
|
|
self.assertEqual(self.org1.owner, self.user1)
|
|
|
|
def test_organisation_employee_relationship(self):
|
|
self.assertTrue(self.org1.members.filter(pk=self.user2.pk).exists())
|
|
|
|
def test_organisation_domain_relationship(self):
|
|
self.assertTrue(self.org1.domains.filter(pk=self.domain.pk).exists())
|
|
|
|
def test_organisation_uuid_generated(self):
|
|
self.assertIsNotNone(self.org1.uuid)
|
|
|
|
def test_organisation_timestamps(self):
|
|
self.assertIsNotNone(self.org1.created_at)
|
|
self.assertIsNotNone(self.org1.updated_at)
|
|
|
|
def test_organisation_created_at_updated_at_close_on_creation(self):
|
|
delta = abs((self.org1.created_at - self.org1.updated_at).total_seconds())
|
|
self.assertLess(delta, 1)
|
|
|
|
def test_organisation_update_changes_updated_at(self):
|
|
original_updated = self.org1.updated_at
|
|
import time
|
|
time.sleep(0.1)
|
|
self.org1.name = "TechCorp Updated"
|
|
self.org1.save()
|
|
self.assertGreater(self.org1.updated_at, original_updated)
|
|
|
|
def test_organisation_count(self):
|
|
self.assertEqual(Organisation.objects.count(), 1)
|
|
|
|
def test_organisation_filter_by_name(self):
|
|
org = Organisation.objects.get(name="TechCorp")
|
|
self.assertEqual(org.id, self.org1.id)
|
|
|
|
def test_organisation_filter_by_manager(self):
|
|
orgs = Organisation.objects.filter(owner=self.user1)
|
|
self.assertEqual(orgs.count(), 1)
|
|
|
|
def test_organisation_delete_cascade(self):
|
|
org_id = self.org1.id
|
|
self.org1.delete()
|
|
with self.assertRaises(Organisation.DoesNotExist):
|
|
Organisation.objects.get(id=org_id)
|
|
|
|
def test_organisation_update_name(self):
|
|
self.org1.name = "NewTechCorp"
|
|
self.org1.save()
|
|
updated = Organisation.objects.get(id=self.org1.id)
|
|
self.assertEqual(updated.name, "NewTechCorp")
|
|
|
|
|
|
class DatasetTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
self.user = User.objects.create_user(email_address="creator@test.com", password="pass123")
|
|
self.domain = Domain.objects.create(name="ML")
|
|
self.dataset1 = Dataset.objects.create(
|
|
domain=self.domain,
|
|
name="Training Data",
|
|
description="Training dataset for ML",
|
|
created_by=self.user
|
|
)
|
|
|
|
def test_dataset_creation(self):
|
|
self.assertEqual(self.dataset1.name, "Training Data")
|
|
|
|
def test_dataset_string_representation(self):
|
|
self.assertEqual(str(self.dataset1), "Training Data (ML)")
|
|
|
|
def test_dataset_domain_relationship(self):
|
|
self.assertEqual(self.dataset1.domain, self.domain)
|
|
|
|
def test_dataset_created_by_relationship(self):
|
|
self.assertEqual(self.dataset1.created_by, self.user)
|
|
|
|
def test_dataset_description_optional(self):
|
|
dataset = Dataset.objects.create(
|
|
domain=self.domain,
|
|
name="Test Data",
|
|
created_by=self.user
|
|
)
|
|
self.assertEqual(dataset.description, "")
|
|
|
|
def test_dataset_uuid_generated(self):
|
|
self.assertIsNotNone(self.dataset1.uuid)
|
|
|
|
def test_dataset_timestamps(self):
|
|
self.assertIsNotNone(self.dataset1.created_at)
|
|
self.assertIsNotNone(self.dataset1.updated_at)
|
|
|
|
def test_dataset_count(self):
|
|
self.assertEqual(Dataset.objects.count(), 1)
|
|
|
|
def test_dataset_filter_by_domain(self):
|
|
datasets = Dataset.objects.filter(domain=self.domain)
|
|
self.assertEqual(datasets.count(), 1)
|
|
|
|
def test_dataset_filter_by_creator(self):
|
|
datasets = Dataset.objects.filter(created_by=self.user)
|
|
self.assertEqual(datasets.count(), 1)
|
|
|
|
def test_dataset_filter_by_name(self):
|
|
dataset = Dataset.objects.get(name="Training Data")
|
|
self.assertEqual(dataset.id, self.dataset1.id)
|
|
|
|
def test_dataset_update_description(self):
|
|
self.dataset1.description = "Updated description"
|
|
self.dataset1.save()
|
|
updated = Dataset.objects.get(id=self.dataset1.id)
|
|
self.assertEqual(updated.description, "Updated description")
|
|
|
|
def test_dataset_delete(self):
|
|
dataset_id = self.dataset1.id
|
|
self.dataset1.delete()
|
|
with self.assertRaises(Dataset.DoesNotExist):
|
|
Dataset.objects.get(id=dataset_id)
|
|
|
|
def test_dataset_multiple_per_domain(self):
|
|
dataset2 = Dataset.objects.create(
|
|
domain=self.domain,
|
|
name="Test Data",
|
|
created_by=self.user
|
|
)
|
|
datasets = Dataset.objects.filter(domain=self.domain)
|
|
self.assertEqual(datasets.count(), 2)
|
|
|
|
def test_dataset_multiple_per_creator(self):
|
|
dataset2 = Dataset.objects.create(
|
|
domain=self.domain,
|
|
name="Test Data 2",
|
|
created_by=self.user
|
|
)
|
|
datasets = Dataset.objects.filter(created_by=self.user)
|
|
self.assertEqual(datasets.count(), 2)
|
|
|
|
def test_dataset_cascade_on_domain_delete(self):
|
|
dataset_id = self.dataset1.id
|
|
self.domain.delete()
|
|
with self.assertRaises(Dataset.DoesNotExist):
|
|
Dataset.objects.get(id=dataset_id)
|
|
|
|
def test_dataset_cascade_on_user_delete(self):
|
|
dataset_id = self.dataset1.id
|
|
self.user.delete()
|
|
with self.assertRaises(Dataset.DoesNotExist):
|
|
Dataset.objects.get(id=dataset_id)
|