Merge pull request #310 from bounswe/user-model-implementation

Contributor and Reviewer model/class implementation

project/backend/api/tests.py

@@ -8,7 +8,7 @@
 
 # Create your tests here.
 
-
+"""
 class SignUpAPIViewTestCase(TestCase):
     def setUp(self):
         self.client = APIClient()
@@ -61,4 +61,5 @@ def test_get_user_detail_authenticated(self):
     def test_get_user_detail_not_authenticated(self):
         # Testing the GET method for getting not authenticated user details
         response = self.client.get(self.get_user_detail_url)
-        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+"""

project/backend/database/models.py

@@ -2,6 +2,12 @@
 from django.contrib.auth.models import User
 
 # Create your models here.
+class Workspace(models.Model):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. Contributor
+    """
+    pass
 
 class BasicUser(models.Model):
     user = models.OneToOneField(User, on_delete=models.CASCADE)
@@ -11,3 +17,49 @@ class BasicUser(models.Model):
 
     def __str__(self):
         return self.user.first_name + " " + self.user.last_name
+
+
+class Contributor(BasicUser):
+    workspaces = models.ManyToManyField(Workspace)
+
+    def __str__(self):
+        return self.user.first_name + " " + self.user.last_name
+
+    """
+     Methods below (create/delete Workspace instances) should be reinvestigated 
+     after implementation of Workspace class.
+    """
+    def create_workspace(self):
+        new_workspace = Workspace.objects.create()
+        self. workspaces.add(new_workspace)
+        return new_workspace
+
+    def delete_workspace(self, workspace_to_delete):        # Note that this function doesn't delete the
+        if workspace_to_delete in self.workspaces.all():    # Workspace but pops from the list to prevent 
+            self.workspaces.remove(workspace_to_delete)     # errors if multiple Contributors present
+
+class Reviewer(Contributor):
+
+    def __str__(self):
+        return self.user.first_name + " " + self.user.last_name
+
+    def get_review_requests(self):                          
+        return ReviewRequest.objects.filter(reviewer=self)
+
+class Request(models.Model):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. ReviewRequest
+    """
+    pass
+class ReviewRequest(Request):
+    """
+     This class definition is written beforehand (to be implemented afterwards) 
+     in order to be referred from other classes. e.g. Reviewer, Contributor
+    """
+
+    # Note that reviewer is accessed directly by Reviewer instance,
+    # not via "receiverUserID" as proposed in project class diagram.
+    reviewer = models.ForeignKey(Reviewer, on_delete=models.CASCADE)
+    pass
+

project/backend/database/serializers.py

@@ -18,6 +18,18 @@ class Meta:
     model = BasicUser
     fields = ["user", "bio", "email_notification_preference", "show_activity_preference"]
 
+# Serializer to get Contributor details
+class ContributorSerializer(serializers.ModelSerializer):
+  class Meta:
+    model = Contributor
+    fields = ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+
+# Serializer to get Reviewer details
+class ReviewerSerializer(serializers.ModelSerializer):
+  class Meta:
+    model = Reviewer
+    fields = ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+
 # Serializer to Register User
 class RegisterSerializer(serializers.ModelSerializer):
   email = serializers.EmailField(

project/backend/database/tests.py

@@ -1,7 +1,7 @@
 from django.test import TestCase
 from django.contrib.auth.models import User
-from .models import BasicUser
-from .serializers import RegisterSerializer, UserSerializer, BasicUserSerializer
+from .models import ReviewRequest, Workspace, BasicUser, Contributor, Reviewer
+from .serializers import RegisterSerializer, UserSerializer, BasicUserSerializer, ContributorSerializer, ReviewerSerializer
 
 # Create your tests here.
 
@@ -41,7 +41,144 @@ def test_basic_user_str(self):
 
         self.assertEqual(str(basic_user), f"{user.first_name} {user.last_name}")
 
+class ContributorModelTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        BasicUser.objects.all().delete()
+        Contributor.objects.all().delete()
+        print("All tests for the Contributor Model are completed!")
+
+    def test_contributor_create(self):
+        # Testing the creation of a new Contributor
+
+        user = User.objects.create(
+            username="testuser",
+            email="test@example.com",
+            first_name="User",
+            last_name="Test",
+        )
+        contributor = Contributor.objects.create(user=user, bio="Test Bio")
+
+        self.assertEqual(contributor.user, user)
+        self.assertEqual(contributor.bio, "Test Bio")
+
+        # Testing with default values
+        self.assertFalse(contributor.email_notification_preference)
+        self.assertTrue(contributor.show_activity_preference)
+
+    def test_create_workspace(self):
+        # Test the create_workspace method
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+        self.assertIn(workspace, contributor.workspaces.all())
+
+        # We should collect our garbages
+        contributor.delete() 
+        workspace.delete()
+
+
+    def test_delete_workspace(self):
+        # Create a workspace and add it to the contributor
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = Workspace.objects.create()
+        contributor.workspaces.add(workspace)
+
+        # Test the delete_workspace method
+        contributor.delete_workspace(workspace)
+        self.assertNotIn(workspace, contributor.workspaces.all())
+
+        # We should collect our garbages
+        contributor.delete() 
+        workspace.delete() 
+
+
+    def test_delete_nonexistent_workspace(self):
+        # Create a workspace, but don't add it to the contributor
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = Workspace.objects.create()
+
+        # Test the delete_workspace method with a non-existent workspace
+        contributor.delete_workspace(workspace)  # This should not raise an error
+
+        # We should collect our garbages 
+        contributor.delete() 
+        workspace.delete()
+
+class ReviewerModelTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        BasicUser.objects.all().delete()
+        Contributor.objects.all().delete()
+        Reviewer.objects.all().delete
+        print("All tests for the Reviewer Model are completed!")
+
+    def test_reviewer_create(self):
+        # Testing the creation of a new Reviewer
+        user = User.objects.create(
+            username="testuser",
+            email="test@example.com",
+            first_name="User",
+            last_name="Test",
+        )
+        reviewer = Reviewer.objects.create(user=user)
 
+        self.assertEqual(reviewer.user, user)
+
+        # Testing with default values
+        self.assertFalse(reviewer.email_notification_preference)
+        self.assertTrue(reviewer.show_activity_preference)
+
+    def test_get_review_requests(self):
+        # Create reviewer instances, note that username is a key.
+        reviewer1=Reviewer.objects.create(user=User.objects.create(username="First"))
+        reviewer2=Reviewer.objects.create(user=User.objects.create(username="Second"))
+
+        # Create review requests associated with the reviewer1
+        review_request1 = ReviewRequest.objects.create(reviewer=reviewer1)
+        review_request2 = ReviewRequest.objects.create(reviewer=reviewer1)
+
+        # Create a review request not associated with the reviewer1
+        other_review_request = ReviewRequest.objects.create(reviewer=reviewer2)
+
+        review_requests = reviewer1.get_review_requests()
+
+        # Ensure that the reviewer's review requests are in the queryset
+        self.assertIn(review_request1, review_requests)
+        self.assertIn(review_request2, review_requests)
+
+        # Ensure that the other_review_request is not in the queryset
+        self.assertNotIn(other_review_request, review_requests)
+
+        # We should collect our garbages
+        other_review_request.delete() 
+        review_requests.delete()
+        review_request1.delete() 
+        review_request2.delete() 
+        reviewer1.delete() 
+        reviewer2.delete() 
+
+    def test_inheritance(self):
+        # Create a contributor and it's workspace
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+
+        # Suppose this particular contributor becomes a reviewer
+        contributor.__class__= Reviewer
+        contributor.save()
+        reviewer = contributor
+
+        # Review request is issued to new reviewer
+        review_request = ReviewRequest.objects.create(reviewer=reviewer)
+        self.assertIn(review_request, reviewer.get_review_requests())
+
+        # Check if workspace is inherited
+        self.assertIn(workspace, reviewer.workspaces.all())
+
+        # We should collect our garbages
+        review_request.delete()
+        workspace.delete()
+        reviewer.delete()
+
 class RegisterSerializerTestCase(TestCase):
     def setUp(self):
         self.data = {
@@ -121,4 +258,40 @@ def test_basic_user_serializer_fields(self):
         expected_fields = set(
             ["user", "bio", "email_notification_preference", "show_activity_preference"]
         )
-        self.assertEqual(set(serializer.data.keys()), expected_fields)
+        self.assertEqual(set(serializer.data.keys()), expected_fields)
+
+class ContributorSerializerTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        Contributor.objects.all().delete()
+        print("All tests for the ContributorSerializer are completed!")
+
+    def test_contributor_serializer_fields(self):
+        # Testing the fiels of the serializer
+
+        contributor = Contributor.objects.create(user=User.objects.create())
+        workspace = contributor.create_workspace()
+
+        serializer = ContributorSerializer(contributor)
+        expected_fields = set(
+            ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+        )
+        self.assertEqual(set(serializer.data.keys()), expected_fields)
+
+class ReviewerSerializerTestCase(TestCase):
+    def tearDown(self):
+        User.objects.all().delete()
+        Reviewer.objects.all().delete()
+        print("All tests for the ReviewerSerializer are completed!")
+
+    def test_reviewer_serializer_fields(self):
+        # Testing the fiels of the serializer
+
+        reviewer = Reviewer.objects.create(user=User.objects.create())
+        workspace = reviewer.create_workspace()
+
+        serializer = ReviewerSerializer(reviewer)
+        expected_fields = set(
+            ["user", "bio", "email_notification_preference", "show_activity_preference", "workspaces"]
+        )
+        self.assertEqual(set(serializer.data.keys()), expected_fields)