added studentView Tests

CDC_Backend/APIs/studentUrls.py

@@ -8,7 +8,7 @@ urlpatterns = [
     path('getDashboard/', studentViews.getDashboard, name="Dashboard"),
     path("addResume/", studentViews.addResume, name="Upload Resume"), 
     path("deleteResume/", studentViews.deleteResume, name="Delete Resume"),
-    path("submitApplication/", studentViews.submitApplication, name="Submit Application"), 
+    path("submitApplication/", studentViews.submitApplication, name="Add Application"), 
     path("deleteApplication/", studentViews.deleteApplication, name="Delete Application"), 
     path("getContributorStats/", studentViews.getContributorStats, name="Get Contributor Stats"),
     path("studentAcceptOffer/", studentViews.studentAcceptOffer, name="Student Accept Offer"), 

CDC_Backend/APIs/studentViews.py

@@ -322,25 +322,35 @@ def getContributorStats(request, id, email, user_type):
         
 #view for sudentAcceptOffer
 @api_view(['POST'])
+@precheck(required_data=[OPENING_ID,"offer_accepted"])  
 @isAuthorized(allowed_users=[STUDENT])
 def studentAcceptOffer(request, id, email, user_type):
     try:
-        company_id = request.data['id']
+        company_id = request.data[OPENING_ID]
-        student_id=request.data['profileInfo']['id']
+        #student_id=request.data['profileInfo']['id']
-        offer_accepted = request.data['offerStatus']
+        student_id=id
+
+        offer_accepted = request.data['offer_accepted']
         if OPENING_TYPE in request.data:
             opening_type = request.data[OPENING_TYPE]
         else:
             opening_type = PLACEMENT
         if opening_type==INTERNSHIP:
-            application=InternshipApplication.objects.get(internship=company_id,student=student_id,selected=True) 
+            application=InternshipApplication.objects.filter(internship=company_id,student=student_id,selected=True) 
         else:
-            application=PlacementApplication.objects.get(placement=company_id,student=student_id,selected=True)
+            application=PlacementApplication.objects.filter(placement=company_id,student=student_id,selected=True)
 
-        application.offer_accepted=offer_accepted
+        if len(application):
-        application.save()
+            application[0].offer_accepted=offer_accepted
-        return Response({'action': "Accept Offer", 'message': "Updated Offer Status"},
+            application[0].save()
+            return Response({'action': "Accept Offer", 'message': "Updated Offer Status"},
                         status=status.HTTP_200_OK)
+        else:
+            return Response({'action': "Accept Offer", 'message': "Offer Not Found"},
+                        status=status.HTTP_404_NOT_FOUND)
+            
+
+        
     except:
         logger.warning("Accept Offer: " + str(sys.exc_info()))
 

CDC_Backend/APIs/test_studentView.py

@@ -0,0 +1,389 @@
+# Create your tests here.
+from .models import *
+from .serializers import *
+from django.test import TestCase, Client
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.urls import reverse
+from .utils import *
+import json
+from django.utils import timezone
+
+
+
+class StudentViewsTestCase(APITestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.user= User.objects.create(
+            email=str(os.environ.get("email")),
+            id=generateRandomString(),
+            user_type=[STUDENT])
+        self.assertEqual(self.user.email, User.objects.get(id=self.user.id).email)
+        self.student = Student.objects.create(
+            name="Test Student",
+            id=self.user.id,
+            resumes=["8BSLybntULgrPPm_beehyv.pdf"],
+           #email="test@student.com",
+            #password="testpassword",
+            roll_no="200010052",
+            branch="CSE",
+            batch="2020",
+            phone_number="1234567890",
+           # resume_link="https://testresume.com"
+            changed_by=self.user,
+            can_apply=True,
+            can_apply_internship=True,
+            degree="bTech",
+            cpi=7.95,
+        )
+        self.assertEqual(self.student.name, Student.objects.get(id=self.student.id).name)
+        # self.user=User.objects.filter(email="200010052@iitdh.ac.in").first()
+        # self.student = Student.objects.filter(id=self.user.id).first()
+        self.internship = Internship.objects.create(
+            company_name="Test Company",
+            id=generateRandomString(),
+            website="https://testwebsite.com",
+            address="Test Address",
+            company_type="Test Company Type",
+            offer_accepted=True,
+            season=["Summer"],
+            allowed_branch=["CSE"],
+            allowed_batch=["2020"],
+            contact_person_name="Test Contact Person",
+            phone_number="1234567890",
+            email="test@test.com",
+            email_verified=True,
+            deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0) + timezone.timedelta(days=1),
+           # location="Test Location",
+            stipend=10000,
+           # apply_link="https://testapplylink.com"
+        )
+       # self.assertEqual(self.internship.company_name, Internship.objects.get(self.internship.id).company_name)
+        # self.internship1 =Internship.objects.create(
+        #     company_name="Test Company1",
+        #     id=generateRandomString(),
+        #     website="https://testwebsite1.com",
+        #     address="Test Address1",
+        #     company_type="Test Company Type1",
+        #     offer_accepted=True,
+        #     season=["Summer"],
+        #     allowed_branch=["CSE"],
+        #     allowed_batch=["2020"],
+        #     contact_person_name="Test Contact Person1",
+        #     phone_number="1234567890",
+        #     email="test@test1.com",
+        #     email_verified=True,
+        #     deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0) + timezone.timedelta(days=1),
+        #     stipend=10000,
+
+        # )
+        self.placement = Placement.objects.create(
+            company_name="Test Company",
+            id=generateRandomString(),
+            website="https://testwebsite.com",
+            address="Test Address",
+            company_type="Test Company Type",
+            offer_accepted=True,
+            tier="6",
+           # season="Summer",
+            allowed_branch=["CSE"],
+            allowed_batch=["2020"],
+            contact_person_name="Test Contact Person",
+            phone_number="1234567890",
+            email="test@test.com",
+            email_verified=True,
+            deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0) + timezone.timedelta(days=1),
+        )
+        # self.placement1 = Placement.objects.create(
+        #     company_name="Test Company1",
+        #     id=generateRandomString(),
+        #     website="https://testwebsite1.com",
+        #     address="Test Address1",
+        #     company_type="Test Company Type1",
+        #     offer_accepted=True,
+        #     tier="7",
+        #     # season="Summer",
+        #     allowed_branch=["CSE"],
+        #     allowed_batch=["2020"],
+        #     contact_person_name="Test Contact Person1",
+        #     phone_number="1234567890",
+        #     email="test@test1.com",
+        #     email_verified=True,
+        #     deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0) + timezone.timedelta(days=1),
+        # )
+        #self.assertEqual(self.placement.tier,"1")
+        self.assertEqual(self.placement.company_name, Placement.objects.get(id=self.placement.id).company_name)
+        self.internship_application = InternshipApplication.objects.create(
+            id=generateRandomString(),
+            internship=self.internship,
+            student=self.student,
+            resume="8BSLybntULgrPPm_beehyv.pdf",
+            selected=True
+           # status="Applied"
+        )
+        # self.internship_application1=InternshipApplication.objects.create(
+        #     id=generateRandomString(),
+        #     internship=self.internship1,
+        #     student=self.student,
+        #     resume="8BSLybntULgrPPm_beehyv.pdf"
+        #     )
+        self.assertEqual(self.internship_application.internship.company_name, InternshipApplication.objects.get(id=self.internship_application.id).internship.company_name)
+        self.placement_application = PlacementApplication.objects.create(
+            id=generateRandomString(),
+            placement=self.placement,
+            student=self.student,
+            resume="8BSLybntULgrPPm_beehyv.pdf",
+            selected=True
+           # status="Applied"
+        )
+        # self.placement_application1 = PlacementApplication.objects.create(
+        #     id=generateRandomString(),
+        #     placement=self.placement1,
+        #     student=self.student,
+        #     resume="8BSLybntULgrPPm_beehyv.pdf",
+        #    # selected=True
+        #    # status="Applied"
+        # )
+        self.assertEqual(self.placement_application.placement.company_name, PlacementApplication.objects.get(id=self.placement_application.id).placement.company_name)
+        self.issue = Issues.objects.create(
+            student=self.student,
+            title="Test Issue",
+            description="Test Issue Description",
+            opening_id=self.internship.id,
+            opening_type=INTERNSHIP
+        )
+        #get token from google OAuth API
+        response=self.client.post(reverse('Refresh Token'), {'refresh_token': os.environ.get("refresh_token")}, format='json')
+        self.student_token=response.data['id_token']
+       # self.student_token = get_access_token_id(os.environ.get("refresh_token"))
+
+        #self.contributor_token = get_token(self.contributor.email, "testpassword", CONTRIBUTOR)
+    
+    def test_student_accept_offer_internship(self):
+        url = reverse('Student Accept Offer')
+        data={
+            'opening_id':self.internship.id,
+            'offer_accepted':True,
+            'opening_type':INTERNSHIP
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], 'Updated Offer Status')
+        self.assertEqual(InternshipApplication.objects.get(id=self.internship_application.id).offer_accepted, True)
+        self.internship_application.selected=False
+        self.internship_application.offer_accepted=False
+        self.internship_application.save()
+
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertEqual(response.data['message'], 'Offer Not Found')
+        self.assertEqual(InternshipApplication.objects.get(id=self.internship_application.id).offer_accepted, False)
+        
+
+    def test_delete_application_internship(self):
+        url = reverse('Delete Application')
+        data = {
+            'application_id': self.internship_application.id,
+            'opening_type': INTERNSHIP
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], 'Application Deleted')
+        self.assertEqual(InternshipApplication.objects.filter(id=self.internship_application.id).count(), 0)
+        self.internship.deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        self.internship.save()
+        self.internship_application=InternshipApplication.objects.create(id=generateRandomString(),
+            internship=self.internship,
+            student=self.student,
+            resume="8BSLybntULgrPPm_beehyv.pdf",
+            selected=True)
+        data['application_id']=self.internship_application.id
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(response.data['message'], 'Deadline Passed')
+        self.assertEqual(InternshipApplication.objects.filter(id=self.internship_application.id).count(), 1)
+        
+
+    def test_add_application_internship(self):
+        url = reverse('Delete Application')
+        data = {
+            'application_id': self.internship_application.id,
+            'opening_type': INTERNSHIP
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], 'Application Deleted')
+        self.assertEqual(InternshipApplication.objects.filter(id=self.internship_application.id).count(), 0)
+        #deleted existing application
+        url = reverse('Add Application')
+        data = {
+            OPENING_ID: self.internship.id,
+            OPENING_TYPE: INTERNSHIP,
+            RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf'
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], 'Application Submitted')
+        self.assertEqual(InternshipApplication.objects.filter(student=self.student).count(), 1)
+        self.internship_application=InternshipApplication.objects.filter(student=self.student)
+        self.internship.deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        self.internship.save()
+        
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(response.data['message'],'Application is already Submitted')
+        self.assertEqual(InternshipApplication.objects.filter(student=self.student).count(), 1)
+        self.internship_application.delete()
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertEqual(response.data['message'],'No Internship matches the given query.')
+        self.assertEqual(InternshipApplication.objects.filter(student=self.student).count(), 0)
+        
+
+    def test_student_accept_offer_placement(self):
+        url=reverse('Student Accept Offer')
+        data={
+            'opening_id':self.placement.id,
+            'offer_accepted':True,
+            'opening_type':PLACEMENT
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response=self.client.post(url,data,format='json')
+        self.assertEqual(response.status_code,status.HTTP_200_OK)
+        self.assertEqual(response.data['message'],'Updated Offer Status')
+        self.assertEqual(PlacementApplication.objects.get(id=self.placement_application.id).offer_accepted,True)
+        self.placement_application.selected=False
+        self.placement_application.offer_accepted=False
+        self.placement_application.save()
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertEqual(response.data['message'], 'Offer Not Found')
+        self.assertEqual(PlacementApplication.objects.get(id=self.placement_application.id).offer_accepted, False)
+        
+    def test_delete_application_placement(self):
+        url=reverse('Delete Application')
+        data={
+            'application_id':self.placement_application.id,
+            'opening_type':PLACEMENT
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response=self.client.post(url,data,format='json')
+        self.assertEqual(response.status_code,status.HTTP_200_OK)
+        self.assertEqual(response.data['message'],'Application Deleted')
+        self.assertEqual(PlacementApplication.objects.filter(id=self.placement_application.id).count(),0)
+        self.placement.deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        self.placement.save()
+        self.placement_application=PlacementApplication.objects.create(id=generateRandomString(),
+            placement=self.placement,
+            student=self.student,
+            resume="8BSLybntULgrPPm_beehyv.pdf",
+            selected=True)
+        data['application_id']=self.placement_application.id
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(response.data['message'], 'Deadline Passed')
+        self.assertEqual(PlacementApplication.objects.filter(id=self.placement_application.id).count(), 1)
+    def test_add_application_placement(self):
+        url=reverse('Delete Application')
+        data={
+            'application_id':self.placement_application.id,
+            'opening_type':PLACEMENT
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response=self.client.post(url,data,format='json')
+        self.assertEqual(response.status_code,status.HTTP_200_OK)
+        self.assertEqual(response.data['message'],'Application Deleted')
+        self.assertEqual(PlacementApplication.objects.filter(id=self.placement_application.id).count(),0)
+        #deleted existing application
+        url=reverse('Add Application')
+        data={
+            OPENING_ID:self.placement.id,
+            OPENING_TYPE:PLACEMENT,
+            RESUME_FILE_NAME:'8BSLybntULgrPPm_beehyv.pdf'
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response=self.client.post(url,data,format='json')
+        self.assertEqual(response.status_code,status.HTTP_200_OK)
+        self.assertEqual(response.data['message'],'Application Submitted')
+        self.assertEqual(PlacementApplication.objects.filter(student=self.student).count(),1)
+        self.placement.deadline_datetime=timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        self.placement.save()
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(response.data['message'], 'Application is already Submitted')
+        self.assertEqual(PlacementApplication.objects.filter(student=self.student).count(), 1)
+        self.placement_application=PlacementApplication.objects.filter(student=self.student)
+        self.placement_application.delete()
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertEqual(response.data['message'], 'No Placement matches the given query.')
+        self.assertEqual(PlacementApplication.objects.filter(student=self.student).count(), 0)
+
+
+
+    def test_dashboard(self):
+        url=reverse('Dashboard')
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response=self.client.get(url,format='json')
+        self.assertEqual(response.status_code,status.HTTP_200_OK)
+        self.assertEqual(response.data['message'],'Data Found')
+        internships=Internship.objects.filter(allowed_batch__contains=[self.student.batch],
+                                              allowed_branch__contains=[self.student.branch],
+                                              deadline_datetime__gte=datetime.datetime.now(),
+                                              offer_accepted=True, email_verified=True)
+        placements=Placement.objects.filter(allowed_batch__contains=[self.student.batch],
+                                                allowed_branch__contains=[self.student.branch],
+                                                deadline_datetime__gte=datetime.datetime.now(),
+                                                offer_accepted=True, email_verified=True)
+      #  self.assertEqual(len(response.data['internships']),len(internships))
+      #  self.assertEqual(PlacementApplicationConditions(self.student,self.placement)[1],"hai")
+      #  self.assertEqual(len(response.data['placements']),len(placements))
+        filtered_internships=internship_eligibility_filters(self.student,internships)
+        filtered_placements=placement_eligibility_filters(self.student,placements)
+        self.assertEqual(len(response.data['internships']),len(filtered_internships))
+        self.assertEqual(len(response.data['placements']),len(filtered_placements))
+        self.assertEqual(len(response.data['placementApplication']),1)
+        self.assertEqual(len(response.data['internshipApplication']),1)
+        self.assertEqual(response.data['placementApplication'][0]['placement']['company_name'],self.placement.company_name)
+        self.assertEqual(response.data['internshipApplication'][0]['internship']['company_name'],self.internship.company_name)
+
+
+
+
+
+
+
+
+
+    # def test_get_contributor_stats(self):
+    #     url = reverse('get_contributor_stats', kwargs={'id': self.student.id})
+    #     self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.contributor_token)
+    #     response = self.client.get(url, format='json')
+    #     self.assertEqual(response.status_code, status.HTTP_200_OK)
+    #     self.assertEqual(response.data['message'], 'Contributor Stats Fetched')
+    #     self.assertEqual(len(response.data['data']), 1)
+    #     self.assertEqual(response.data['data'][0]['name'], self.contributor.name)
+    #     self.assertEqual(response.data['data'][0]['email'], self.contributor.email)
+    #     self.assertEqual(response.data['data'][0]['contribution_count'], self.contributor.contribution_count)
+
+    
+    def test_add_issue(self):
+        url = reverse('Add Issue')
+        data = {
+            'Title': 'Test Issue 2',
+            'Description': 'Test Issue Description 2',
+            'opening_id': self.placement.id,
+            'opening_type': PLACEMENT
+        }
+        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.student_token)
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['message'], 'Issue Added')
+        self.assertEqual(Issues.objects.filter(student=self.student).count(), 2)
+        self.assertEqual(Issues.objects.filter(opening_id=self.placement.id).count(), 1)
+        self.assertEqual(Issues.objects.filter(opening_type=PLACEMENT).count(), 1)
+