def test_get_recommended_supervisors(self):
        # Register supervisor
        create_new_user("Yeesha", "Woozles", user_type=SUPERVISOR)
        create_new_user("Pluto", "Woozles", user_type=SUPERVISOR)

        # Login as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        create_new_application(token, create_application_details(registry_ref="015243",
                                                                 academic_year_id=self.academic_year.id,
                                                                 supervisors=['Yeesha'],
                                                                 tags=['Porsche']), self.client)

        create_new_application(token, create_application_details(registry_ref="767575",
                                                                 academic_year_id=self.academic_year.id,
                                                                 supervisors=['Yeesha', 'Pluto'],
                                                                 tags=['Porsche', 'Ferrari']), self.client)

        recommended_supervisors_response = self.client.get(path="/api/phd/recommended_supervisors/",
                                                           data={'tags': ['Porsche', 'Ferrari']},
                                                           HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(recommended_supervisors_response.status_code, 200)
        response_content = json.loads(recommended_supervisors_response.content.decode('utf-8'))
        self.assertEqual(len(response_content), 2)
        self.assertEqual(response_content[0]['total'], 2)
        self.assertEqual(response_content[0]['username'], 'Yeesha')
    def test_download_csv(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # Register two supervisors
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)
        create_new_user("Atrus2", "Woozles", user_type=SUPERVISOR)

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id,
                                       registry_ref="01",
                                       supervisors=['Atrus1', 'Atrus2']),
            self.client)

        application = Application.objects.filter(registry_ref="01").first()
        download_response = self.client.get(
            "/api/phd/csv_download/", {
                "token": token,
                "application_ids": [application.id],
                "sort_field": "registry_ref",
                "sort_by": "DESC",
                "selected_fields": ["registry_ref", "forename"]
            })
        self.assertEquals(download_response.get('Content-Type'), 'text/csv')
    def test_download_zip(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # Register two supervisors
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)
        create_new_user("Atrus2", "Woozles", user_type=SUPERVISOR)

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id,
                                       registry_ref="01",
                                       supervisors=['Atrus1', 'Atrus2']),
            self.client)

        # Log in as Atrus1
        token = log_in(self.client, "Atrus1", "Woozles")

        # POST new file
        application = Application.objects.filter(registry_ref="01").first()
        supervision = application.supervisions.filter(
            supervisor__username="******").first()
        request_details = json.dumps({
            "supervision_id": supervision.id,
            "file_descriptions": {
                'APPLICATION_FORM_1': 'This is my description.'
            }
        })

        with open('phdadmissions/tests/test_file.pdf') as fp:
            self.client.post(
                '/api/phd/file/',
                {
                    'details': request_details,
                    'APPLICATION_FORM_1': fp
                },
                HTTP_AUTHORIZATION='JWT {}'.format(token),
            )

        download_response = self.client.get(
            "/api/phd/zip_download/", {
                "token": token,
                "application_ids": [application.id],
                "sort_field": "registry_ref",
                "sort_by": "DESC",
                "selected_fields": ["registry_ref", "forename"]
            })
        self.assertEquals(download_response.get('Content-Type'),
                          'application/x-zip-compressed')
Beispiel #4
0
    def test_staff_statistics(self):

        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New application
        create_new_application(
            token, create_application_details(self.academic_year.id),
            self.client)

        statistics_response = self.client.get(
            path="/api/phd/statistics/staff/",
            data={},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(statistics_response.status_code, 200)
    def test_get_email_preview(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id,
                                       supervisors=[],
                                       registry_ref="012345"), self.client)
        latest_application = Application.objects.latest(
            field_name="created_at")

        # Register a supervisor
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)
        supervisor = User.objects.get(username="******")
        supervisor.first_name = "Atrus"
        supervisor.last_name = "Venus"
        supervisor.save()

        # Add supervision
        new_supervision = Supervision.objects.create(
            application=latest_application, supervisor=supervisor)

        # Get the email preview
        email_preview_response = self.client.post(
            "/api/phd/admin/email_preview/", {
                "email_template":
                """"<b>Dear Chanapata</b><hr><p>{{supervisor_first_name}} {{supervisor_last_name}}
                                {{registry_ref}}""",
                "supervision_id": new_supervision.id
            },
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        response_content = email_preview_response
        self.assertContains(response_content, latest_application.registry_ref)
        self.assertContains(response_content, supervisor.first_name)
        self.assertContains(response_content, supervisor.last_name)

        # Get the email preview without a template
        email_preview_response = self.client.post(
            "/api/phd/admin/email_preview/", {"email_template": ""},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        response_content = email_preview_response
        self.assertEquals(response_content.status_code, 200)
Beispiel #6
0
    def test_basic_statistics(self):

        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New application
        create_new_application(
            token, create_application_details(self.academic_year.id),
            self.client)

        statistics_response = self.client.get(
            path="/api/phd/statistics/",
            data={},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(statistics_response.status_code, 200)

        statistics_response_content = json.loads(
            statistics_response.content.decode('utf-8'))
        self.assertEqual(statistics_response_content["number_of_applications"],
                         1)
    def test_send_email(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id,
                                       supervisors=[],
                                       registry_ref="012345"), self.client)
        latest_application = Application.objects.latest(
            field_name="created_at")

        # Register a supervisor
        create_new_user("Atrus1",
                        "Woozles",
                        user_type=SUPERVISOR,
                        email="*****@*****.**")
        supervisor = User.objects.get(username="******")

        # Add supervision
        new_supervision = Supervision.objects.create(
            application=latest_application, supervisor=supervisor)

        # Attempt to send the email with missing arguments
        email_send_response = self.client.post(
            "/api/phd/admin/email_send/",
            {"supervision_id": new_supervision.id},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEquals(email_send_response.status_code, 400)

        # Attempt to send the email with missing arguments
        email_send_response = self.client.post(
            "/api/phd/admin/email_send/", {"email_template": ""},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEquals(email_send_response.status_code, 400)
    def test_get_post_delete_tags_of_application(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New applications
        create_new_application(token, create_application_details(self.academic_year.id, registry_ref="01",
                                                                 tags=['Ferrari', 'Porsche']),
                               self.client)
        create_new_application(token, create_application_details(self.academic_year.id, registry_ref="02",
                                                                 tags=['Lamborghini', 'Audi']),
                               self.client)
        create_new_application(token, create_application_details(self.academic_year.id, registry_ref="03",
                                                                 tags=['Ferrari', 'Audi']),
                               self.client)

        self.client.post("/api/phd/admin/tags/", {
            "name": "Tag with no application"
        }, HTTP_AUTHORIZATION='JWT {}'.format(token))

        tags_response = self.client.get("/api/phd/application/tags/",
                                        HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(tags_response.status_code, 200)
        response_content = json.loads(tags_response.content.decode('utf-8'))
        self.assertEqual(len(response_content), 5)

        self.assertEqual(response_content['Ferrari']['count'], 2)
        self.assertEqual(response_content['Porsche']['count'], 1)
        self.assertEqual(response_content['Tag with no application']['count'], 0)

        # POST new tags
        existing_application = Application.objects.filter(registry_ref="01").first()
        self.client.post("/api/phd/application/tags/", {
            "application_id": existing_application.id,
            "name": "Toyota"
        }, HTTP_AUTHORIZATION='JWT {}'.format(token))

        tags_response = self.client.get("/api/phd/application/tags/",
                                        HTTP_AUTHORIZATION='JWT {}'.format(token))

        response_content = json.loads(tags_response.content.decode('utf-8'))
        self.assertEqual(len(response_content), 6)

        self.assertEqual(response_content['Toyota']['count'], 1)

        # DELETE tag
        toyota_tag = Tag.objects.filter(name="Toyota").first()
        delete_tag_response = self.client.delete(path="/api/phd/application/tags/",
                                                 data=json.dumps({"tag_id": toyota_tag.id,
                                                                  "application_id": existing_application.id}),
                                                 HTTP_AUTHORIZATION='JWT {}'.format(token),
                                                 content_type='application/json')

        self.assertEqual(delete_tag_response.status_code, 204)

        tags_response = self.client.get("/api/phd/application/tags/",
                                        HTTP_AUTHORIZATION='JWT {}'.format(token))

        response_content = json.loads(tags_response.content.decode('utf-8'))
        self.assertEqual(len(response_content), 6)

        self.assertEqual(response_content['Toyota']['count'], 0)
    def test_get_post_update_delete_tags(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New application
        create_new_application(token, create_application_details(self.academic_year.id, tags=['Ferrari', 'Porsche']),
                               self.client)

        # GET tags
        tags_response = self.client.get("/api/phd/admin/tags/", HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(tags_response.status_code, 200)
        response_content = json.loads(tags_response.content.decode('utf-8'))
        self.assertEqual(len(response_content["tags"]), 2)

        # POST duplicate tag
        new_tags_response = self.client.post("/api/phd/admin/tags/", {
            "name": 'Ferrari'
        }, HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(new_tags_response.status_code, 400)

        # POST good tag
        new_tags_response = self.client.post("/api/phd/admin/tags/", {
            "name": 'Lamborghini'
        }, HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(new_tags_response.status_code, 201)

        # UPDATE existing tag
        existing_tag = Tag.objects.filter(name="Lamborghini").first()
        existing_tag.name = "Lamborghini 02"
        tag_serializer = TagSerializer(existing_tag)
        update_tag_response = self.client.put(path="/api/phd/admin/tags/",
                                              data=json.dumps(
                                                  {"id": existing_tag.id, "tag": tag_serializer.data}),
                                              HTTP_AUTHORIZATION='JWT {}'.format(token),
                                              content_type='application/json')

        self.assertEqual(update_tag_response.status_code, 200)

        tags_response = self.client.get("/api/phd/admin/tags/", HTTP_AUTHORIZATION='JWT {}'.format(token))
        response_content = json.loads(tags_response.content.decode('utf-8'))
        existing_tag_names = [tag['name'] for tag in response_content["tags"]]
        self.assertIn("Lamborghini 02", existing_tag_names)

        # UPDATE duplicate tag
        existing_tag.name = "Ferrari"
        tag_serializer = TagSerializer(existing_tag)
        update_tag_response = self.client.put(path="/api/phd/admin/tags/",
                                              data=json.dumps(
                                                  {"id": existing_tag.id, "tag": tag_serializer.data}),
                                              HTTP_AUTHORIZATION='JWT {}'.format(token),
                                              content_type='application/json')

        self.assertEqual(update_tag_response.status_code, 400)

        # DELETE a tag
        delete_tag_response = self.client.delete(path="/api/phd/admin/tags/",
                                                 data=json.dumps({"id": existing_tag.id}),
                                                 HTTP_AUTHORIZATION='JWT {}'.format(token),
                                                 content_type='application/json')

        self.assertEqual(delete_tag_response.status_code, 204)
        existing_tag = Tag.objects.filter(name="Lamborghini 02").first()
        self.assertEqual(existing_tag, None)
    def test_new_phd_application(self):
        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # Register two supervisors
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)
        create_new_user("Atrus2", "Woozles", user_type=SUPERVISOR)

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id,
                                       registry_ref="01",
                                       supervisors=['Atrus1', 'Atrus2']),
            self.client)

        # Log in as Atrus1
        token = log_in(self.client, "Atrus1", "Woozles")

        # POST new file
        application = Application.objects.filter(registry_ref="01").first()
        supervision = application.supervisions.filter(
            supervisor__username="******").first()
        request_details = json.dumps({
            "supervision_id": supervision.id,
            "file_descriptions": {
                'APPLICATION_FORM_1': 'This is my description.'
            }
        })

        with open('phdadmissions/tests/test_file.pdf') as fp:
            file_response = self.client.post(
                '/api/phd/file/',
                {
                    'details': request_details,
                    'APPLICATION_FORM_1': fp
                },
                HTTP_AUTHORIZATION='JWT {}'.format(token),
            )
            self.assertEqual(file_response.status_code, 201)
            fp.close()

        supervision = application.supervisions.filter(
            supervisor__username="******").first()
        self.assertEqual(supervision.documentations.count(), 1)
        documentation = supervision.documentations.first()
        self.assertEqual(documentation.file_type, APPLICATION_FORM)
        self.assertEqual(documentation.description, 'This is my description.')

        # Download the file
        download_response = self.client.get("/api/phd/download/", {
            "id": documentation.id,
            "token": token
        })
        self.assertEquals(download_response.get('Content-Disposition'),
                          'attachment; filename=' + documentation.file_name)

        # DELETE file
        delete_file_response = self.client.delete(
            path="/api/phd/file/",
            data=json.dumps({"file_id": documentation.id}),
            HTTP_AUTHORIZATION='JWT {}'.format(token),
            content_type='application/json')

        self.assertEqual(delete_file_response.status_code, 204)
        supervision = application.supervisions.filter(
            supervisor__username="******").first()
        self.assertEqual(supervision.documentations.count(), 0)
    def test_add_and_delete_supervision(self):

        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # Register a supervisor
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)

        # New application
        create_new_application(
            token,
            create_application_details(self.academic_year.id, supervisors=[]),
            self.client)
        latest_application = Application.objects.latest(
            field_name="created_at")

        # Add supervision
        new_supervision_response = self.client.post(
            "/api/phd/supervision/", {
                "id": latest_application.id,
                "supervisor": "Atrus1"
            },
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        self.assertEqual(new_supervision_response.status_code, 200)

        response_content = json.loads(
            new_supervision_response.content.decode('utf-8'))
        self.assertEqual(response_content["supervisor"]["username"], "Atrus1")

        latest_application = Application.objects.latest(
            field_name="created_at")
        supervisions = latest_application.supervisions.all()
        self.assertEqual(
            len(supervisions), 2,
            "We expect 2 supervisions, because one belongs to the admins.")

        # Allocate supervision
        self.assertEqual(response_content["allocated"], False)
        supervision_id = response_content["id"]
        self.client.post("/api/phd/supervision_allocation/",
                         {"supervision_id": supervision_id},
                         HTTP_AUTHORIZATION='JWT {}'.format(token))

        supervision = Supervision.objects.filter(id=supervision_id).first()
        self.assertEqual(supervision.allocated, True)

        post_data = json.dumps({"supervision_id": supervision_id})
        self.client.delete("/api/phd/supervision_allocation/",
                           data=post_data,
                           HTTP_AUTHORIZATION='JWT {}'.format(token))

        supervision = Supervision.objects.filter(id=supervision_id).first()
        self.assertEqual(supervision.allocated, False)

        # Delete supervision
        post_data = json.dumps({
            "id":
            latest_application.id,
            "supervisor":
            "Atrus1",
            "supervision_id":
            supervisions.filter(type=SUPERVISOR).first().id
        })
        self.client.delete("/api/phd/supervision/",
                           data=post_data,
                           HTTP_AUTHORIZATION='JWT {}'.format(token))

        latest_application = Application.objects.latest(
            field_name="created_at")
        supervisions = latest_application.supervisions.all()
        self.assertEqual(len(supervisions), 1)
    def test_application_search(self):

        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # New applications
        post_data = create_application_details(
            self.academic_year.id,
            registry_ref="012983234",
            surname="Szeles",
            forename="Marton",
            possible_funding=["SELF"],
            funding_status="PENDING",
            origin="EU",
            student_type="COMPUTING",
            supervisors=[],
            research_subject="Investigating travelling at the speed of light.",
            administrator_comment=None,
            file_descriptions=[],
            tags=["Ferrari"])
        create_new_application(token, post_data, self.client)

        post_data = create_application_details(
            self.academic_year.id,
            registry_ref="7374636",
            surname="Atrus",
            forename="Yeesha",
            possible_funding=["SELF"],
            funding_status="PENDING",
            origin="OVERSEAS",
            student_type="COMPUTING_AND_CDT",
            supervisors=[],
            research_subject="Investigating writing linking books.",
            administrator_comment=None,
            file_descriptions=[],
            tags=["Porsche", "Mercedes", "Ferrari"])
        create_new_application(token, post_data, self.client)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {"surname": "Szeles"},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 1)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {"forename": "a"},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 2)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {
                "forename": "a",
                "origin": "EU"
            },
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 1)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {"origin": ["EU", "OVERSEAS"]},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 2)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {"tags": ["Porsche", "Mercedes"]},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 1)

        # Search
        search_result_response = self.client.get(
            "/api/phd/search/", {"tags": ["Ferrari"]},
            HTTP_AUTHORIZATION='JWT {}'.format(token))

        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        applications = search_result_response_content["applications"]
        self.assertEqual(len(applications), 2)
    def test_new_phd_application(self):

        # Log in as the admin
        token = log_in(self.client, "Heffalumps", "Woozles")

        # Register two supervisors
        create_new_user("Atrus1", "Woozles", user_type=SUPERVISOR)
        create_new_user("Atrus2", "Woozles", user_type=SUPERVISOR)

        # New application
        new_application_response = create_new_application(
            token, create_application_details(self.academic_year.id),
            self.client)
        self.assertEqual(new_application_response.status_code, 201)

        latest_application = Application.objects.latest(
            field_name="created_at")
        self.assertEqual(latest_application.forename, "Marton")
        self.assertEqual(latest_application.status, PENDING_STATUS)
        self.assertEqual(latest_application.administrator_comment, None)
        self.assertEqual(
            len(latest_application.supervisions.filter(type=SUPERVISOR)), 2)
        self.assertEqual(len(latest_application.tags.all()), 2)

        # Update application
        put_data = json.loads(
            create_application_details(
                self.academic_year.id,
                registry_ref="9874334",
                surname="Szeles",
                forename="Martin",
                possible_funding=["SELF"],
                funding_status="PENDING",
                origin="EU",
                student_type="COMPUTING",
                status="PENDING",
                supervisors=[],
                research_subject=
                "Investigating travelling at the speed of light.",
                administrator_comment="Awesome",
                file_descriptions=[]))

        update_json = json.dumps({
            "id": latest_application.id,
            "application": put_data
        })
        update_application_response = self.client.put(
            path="/api/phd/application/",
            data=update_json,
            HTTP_AUTHORIZATION='JWT {}'.format(token),
            content_type='application/json')

        self.assertEqual(update_application_response.status_code, 200)

        latest_application = Application.objects.latest(
            field_name="created_at")
        self.assertEqual(latest_application.forename, "Martin")
        self.assertEqual(latest_application.administrator_comment, "Awesome")

        # Check if we can read the data through the endpoint
        search_result_response = self.client.get(
            "/api/phd/application/", {"id": latest_application.id},
            HTTP_AUTHORIZATION='JWT {}'.format(token))
        search_result_response_content = json.loads(
            search_result_response.content.decode('utf-8'))
        application = search_result_response_content["application"]
        self.assertEqual(application["forename"], "Martin")
        self.assertEqual(len(application["supervisions"]), 3)

        # Delete
        delete_application_response = self.client.delete(
            path="/api/phd/application/",
            data=json.dumps({"id": application["id"]}),
            HTTP_AUTHORIZATION='JWT {}'.format(token),
            content_type='application/json')

        self.assertEqual(delete_application_response.status_code, 204)