fishy/Dynavera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added domain models, serializers, viewsets, tests and admin view

Browse source
This commit is contained in:
Viswamedha Nalabotu 2025-12-07 15:23:22 +00:00
parent 78e06719af
commit a4db6261a9
6 changed files with 415 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
apps/domains/admin.py
View file

@ -1,3 +1,38 @@
from django.contrib import admin
from apps.domains.models import Domain, Organisation, Dataset
# Register your models here.
@admin.register(Domain)
class DomainAdmin(admin.ModelAdmin):
list_display = ('name', 'uuid')
search_fields = ('name',)
readonly_fields = ('uuid',)
fieldsets = (
(None, {'fields': ('name', 'uuid')}),
('Description', {'fields': ('description',)}),
)
@admin.register(Organisation)
class OrganisationAdmin(admin.ModelAdmin):
list_display = ('name', 'uuid', 'created_at', 'updated_at')
search_fields = ('name',)
readonly_fields = ('uuid', 'created_at', 'updated_at')
fieldsets = (
(None, {'fields': ('name', 'uuid')}),
('Relations', {'fields': ('managers', 'employees', 'domains')}),
('Dates', {'fields': ('created_at', 'updated_at')}),
)
@admin.register(Dataset)
class DatasetAdmin(admin.ModelAdmin):
list_display = ('name', 'domain', 'uuid', 'created_by', 'created_at')
search_fields = ('name', 'domain__name')
readonly_fields = ('uuid', 'created_at', 'updated_at')
fieldsets = (
(None, {'fields': ('name', 'uuid')}),
('Details', {'fields': ('domain', 'description', 'created_by')}),
('File', {'fields': ('datafile',)}),
('Dates', {'fields': ('created_at', 'updated_at')}),
)

32
apps/domains/migrations/0001_initial.py
View file

@ -1,6 +1,8 @@
# Generated by Django 5.2.8 on 2025-11-19 14:22
# Generated by Django 5.2.8 on 2025-12-07 15:22
import django.db.models.deletion
import uuid
from django.conf import settings
from django.db import migrations, models
@ -9,6 +11,7 @@ class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
@ -17,6 +20,7 @@ class Migration(migrations.Migration):
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)),
('description', models.TextField(blank=True, default='')),
],
),
@ -24,11 +28,33 @@ class Migration(migrations.Migration):
name='Dataset',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
('updated_at', models.DateTimeField(auto_now=True, verbose_name='Updated At')),
('name', models.CharField(max_length=255)),
('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)),
('description', models.TextField(blank=True, default='')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('datafile', models.FileField(upload_to='datasets/')),
('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='created_datasets', to=settings.AUTH_USER_MODEL)),
('domain', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='datasets', to='domains.domain')),
],
options={
'abstract': False,
},
),
migrations.CreateModel(
name='Organisation',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
('updated_at', models.DateTimeField(auto_now=True, verbose_name='Updated At')),
('name', models.CharField(max_length=255, unique=True)),
('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)),
('domains', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='organisations', to='domains.domain')),
('employees', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='organisations', to=settings.AUTH_USER_MODEL)),
('managers', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='managed_organisations', to=settings.AUTH_USER_MODEL)),
],
options={
'abstract': False,
},
),
]

47
apps/domains/models.py
View file

@ -1,22 +1,45 @@
from django.db import models
from django.db.models import (
CASCADE,
CharField,
FileField,
ForeignKey,
UUIDField,
Model,
TextField,
)
from uuid import uuid4
from apps.users.models import TimeStampMixin, User
class Domain(models.Model):
class Domain(Model):
name = models.CharField(max_length = 255, unique = True)
description = models.TextField(blank = True, default = "")
name = CharField(max_length = 255, unique = True)
uuid = UUIDField(default = uuid4, editable = False, unique = True)
description = TextField(blank = True, default = "")
def __str__(self) -> str: # pragma: no cover - trivial
def __str__(self) -> str:
return self.name
class Organisation(TimeStampMixin, Model):
class Dataset(models.Model):
name = CharField(max_length = 255, unique = True)
uuid = UUIDField(default = uuid4, editable = False, unique = True)
managers = ForeignKey(User, on_delete = CASCADE, related_name = "managed_organisations")
employees = ForeignKey(User, on_delete = CASCADE, related_name = "organisations")
domains = ForeignKey(Domain, on_delete = CASCADE, related_name = "organisations")
domain = models.ForeignKey(Domain, on_delete = models.CASCADE, related_name = "datasets")
name = models.CharField(max_length = 255)
description = models.TextField(blank = True, default = "")
created_at = models.DateTimeField(auto_now_add = True)
updated_at = models.DateTimeField(auto_now = True)
def __str__(self) -> str:
return self.name
def __str__(self) -> str: # pragma: no cover - trivial
class Dataset(TimeStampMixin, Model):
domain = ForeignKey(Domain, on_delete = CASCADE, related_name = "datasets")
name = CharField(max_length = 255)
uuid = UUIDField(default = uuid4, editable = False, unique = True)
description = TextField(blank = True, default = "")
created_by = ForeignKey(User, on_delete = CASCADE, related_name = "created_datasets")
datafile = FileField(upload_to = "datasets/")
def __str__(self) -> str:
return f"{self.name} ({self.domain.name})"

23
apps/domains/serializers.py Normal file
View file

@ -0,0 +1,23 @@
from rest_framework.serializers import ModelSerializer
from apps.domains.models import Domain, Organisation, Dataset
class DomainSerializer(ModelSerializer):
class Meta:
model = Domain
fields = ['id', 'name', 'description', 'uuid']
class OrganisationSerializer(ModelSerializer):
class Meta:
model = Organisation
fields = ['id', 'name', 'managers', 'employees', 'domains', 'uuid', 'created_at', 'updated_at']
class DatasetSerializer(ModelSerializer):
class Meta:
model = Dataset
fields = ['id', 'domain', 'name', 'description', 'uuid', 'created_by', 'datafile', 'created_at', 'updated_at']

265
apps/domains/tests.py
View file

@ -1,3 +1,266 @@
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
# Create your tests here.
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")
self.org1 = Organisation.objects.create(
name="TechCorp",
managers=self.user1,
employees=self.user2,
domains=self.domain
)
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",
managers=self.user1,
employees=self.user2,
domains=self.domain
)
def test_organisation_manager_relationship(self):
self.assertEqual(self.org1.managers, self.user1)
def test_organisation_employee_relationship(self):
self.assertEqual(self.org1.employees, self.user2)
def test_organisation_domain_relationship(self):
self.assertEqual(self.org1.domains, self.domain)
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(managers=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)

28
apps/domains/viewsets.py Normal file
View file

@ -0,0 +1,28 @@
from rest_framework.viewsets import ModelViewSet
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from apps.domains.models import Domain, Organisation, Dataset
from apps.domains.serializers import DomainSerializer, OrganisationSerializer, DatasetSerializer
class DomainViewSet(ModelViewSet):
queryset = Domain.objects.all()
serializer_class = DomainSerializer
permission_classes = [IsAuthenticatedOrReadOnly]
lookup_field = 'uuid'
class OrganisationViewSet(ModelViewSet):
queryset = Organisation.objects.all()
serializer_class = OrganisationSerializer
permission_classes = [IsAuthenticatedOrReadOnly]
lookup_field = 'uuid'
class DatasetViewSet(ModelViewSet):
queryset = Dataset.objects.all()
serializer_class = DatasetSerializer
permission_classes = [IsAuthenticatedOrReadOnly]
lookup_field = 'uuid'