test_vacancies.py

import json
from datetime import datetime, timedelta

import requests_mock
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.utils import timezone
from rest_framework import status
from rest_framework.test import APITestCase, APIRequestFactory

from core.models.accounts import Company, Student, Supervisor
from core.models.vacancies import Vacancy, Application, VacancyMilestone
from core.serializers.vacancies import VacancySerializer
from core.tests.mocks import mock_csui_oauth_verify, mock_csui_ldap_student, mock_csui_siak_student
from core.views.vacancies import date_validator


class ApplicationTests(APITestCase):
    def get_student_id(self, mock_obj):
        mock_csui_oauth_verify(mock_obj)
        mock_csui_ldap_student(mock_obj)
        mock_csui_siak_student(mock_obj)
        login_url = '/api/login/'
        response = self.client.post(login_url,
                                    {'username': 'dummy.mahasiswa', 'password': 'lalala', 'login-type': 'sso-ui'},
                                    format='json')
        return response.data.get('student').get('id')

    @requests_mock.Mocker()
    def test_application_list(self, m):
        student_id = self.get_student_id(m)
        url = '/api/students/' + str(student_id) + '/applied-vacancies/'
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

    @requests_mock.Mocker()
    def test_application_search(self, m):
        student_id = self.get_student_id(m)
        url = '/api/students/' + str(student_id) + '/applied-vacancies/?search=engineer'
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

    @requests_mock.Mocker()
    def test_application_create_and_delete(self, m):
        student_id = self.get_student_id(m)
        new_user = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", max_accepted_applicants=3, working_period="3 Bulan",
                                             requirements="requirements",
                                             close_time=(timezone.now() + timedelta(days=1)))

        url = '/api/students/' + str(student_id) + '/applied-vacancies/'
        response = self.client.post(url, {'vacancy_id': new_vacancy.pk, 'cover_letter': 'this is a cover letter.'},
                                    format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        url = '/api/students/' + str(student_id) + '/applied-vacancies/' + str(new_vacancy.pk) + '/'
        response = self.client.delete(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_count_application_a_person_is_already_register(self):
        new_user = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_user2 = User.objects.create_user('dummy.student', 'dummy.student@student.com', 'lalala123')

        self.client.force_authenticate(new_user)
        self.client.force_authenticate(new_user2)

        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", close_time=datetime.today(),
                                             max_accepted_applicants=3, working_period="3 Bulan")

        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="lorem ipsum")

        url = '/api/applications/' + str(new_vacancy.pk) + '/count/'

        response = self.client.get(url, format='json')

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.json()['count'], 1)

    def test_count_application_nobody_register(self):
        new_user = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_user2 = User.objects.create_user('dummy.student', 'dummy.student@student.com', 'lalala123')

        self.client.force_authenticate(new_user)
        self.client.force_authenticate(new_user2)

        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        Student.objects.create(user=new_user2, npm=1234123412)
        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", close_time=datetime.today(),
                                             max_accepted_applicants=3, working_period="3 Bulan")

        url = '/api/applications/' + str(new_vacancy.pk) + '/count/'

        response = self.client.get(url, format='json')

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.json()['count'], 0)

    @requests_mock.Mocker()
    def test_cannot_create_application_if_vacancy_is_closed(self, m):
        student_id = self.get_student_id(m)
        new_user = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", close_time=(timezone.now() - timedelta(days=1)),
                                             max_accepted_applicants=3, working_period="3 Bulan")
        url = '/api/students/' + str(student_id) + '/applied-vacancies/'
        response = self.client.post(url, {'vacancy_id': new_vacancy.pk, 'cover_letter': 'this is a cover letter.'},
                                    format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)


class BookmarkApplicationTests(APITestCase):
    @requests_mock.Mocker()
    def setUp(self, m):
        mock_csui_oauth_verify(m)
        mock_csui_ldap_student(m)
        mock_csui_siak_student(m)
        login_url = '/api/login/'
        response = self.client.post(login_url,
                                    {'username': 'dummy.mahasiswa', 'password': 'lalala', 'login-type': 'sso-ui'},
                                    format='json')
        self.student_id = response.data.get('student').get('id')

    def test_application_list(self):
        url = '/api/students/' + str(self.student_id) + '/bookmarked-vacancies/'
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_search_bookmarked_application(self):
        url = '/api/students/' + str(self.student_id) + '/bookmarked-vacancies/?search=engineer'
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_application_create_and_delete(self):
        new_user = User.objects.create_user('dummy.company2', 'dummy.compan2y@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, requirements="requirements",
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")

        url = '/api/students/' + str(self.student_id) + '/bookmarked-vacancies/'
        response = self.client.post(url, {'vacancy_id': new_vacancy.pk}, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        url = '/api/students/' + str(self.student_id) + '/bookmarked-vacancies/' + str(new_vacancy.pk) + '/'
        response = self.client.delete(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)


class VacancyTest(APITestCase):
    def login(self, mock_obj):
        mock_csui_oauth_verify(mock_obj)
        mock_csui_ldap_student(mock_obj)
        mock_csui_siak_student(mock_obj)
        login_url = '/api/login/'
        self.client.post(login_url, {'username': 'dummy.mahasiswa', 'password': 'lalala', 'login-type': 'sso-ui'},
                         format='json')

    def test_verified_vacancy_list(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        url = '/api/vacancies/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    @requests_mock.Mocker()
    def test_search_vacancy(self, m):
        superuser = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        company = Company.objects.create(user=superuser, description="This is a test company")
        Vacancy.objects.create(company=company, open_time=datetime.now(), close_time=datetime.now(),
                               name="Software Engineer", max_accepted_applicants=3, working_period="3 Bulan")
        Vacancy.objects.create(company=company, open_time=datetime.now(), close_time=datetime.now(),
                               name="Data Engineer", max_accepted_applicants=3, working_period="3 Bulan")

        self.login(m)
        url = '/api/vacancies/?search=software'
        response = self.client.get(url, format='json')
        self.assertEqual(1, Company.objects.all().count())
        self.assertEqual(2, Vacancy.objects.all().count())
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_unverified_vacancy_list(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        url = '/api/vacancies/?verified=false'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_filter_vacancy_list_by_company_ids(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.companyzxc', 'dummy.companyzxc@company.com', 'lalala123')
        new_company2 = Company.objects.create(user=new_user2, description="lalalaasdsad", status=Company.VERIFIED,
                                              logo=None,
                                              address=None)
        open_time = datetime(2019, 10, 20)
        close_time = datetime(2019, 12, 20)
        Vacancy.objects.create(company=new_company, verified=True, open_time=open_time,
                               description='', close_time=close_time, name='vacancy1', max_accepted_applicants=3,
                               working_period="3 Bulan")
        Vacancy.objects.create(company=new_company2, verified=True, open_time=open_time,
                               description='', close_time=close_time, name='vacancy2', max_accepted_applicants=3,
                               working_period="3 Bulan")
        url = '/api/vacancies/?company={}&company={}'.format(new_company.id, new_company2.id)
        response = self.client.get(url, format='json')
        Vacancy.objects.filter(company__id__in=[new_company.id, new_company2.id])
        self.assertEqual(dict(response.data)['count'], Vacancy.objects.count())
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_sort_vacancies(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        open_time = datetime(2019, 10, 20)
        close_time = datetime(2019, 12, 20)
        v1 = Vacancy.objects.create(company=new_company, verified=True, open_time=open_time, salary=3000000,
                               description='', close_time=close_time, name='vacancy1', max_accepted_applicants=3,
                               working_period="3 Bulan")
        v1.created = datetime(2019, 12, 10)
        v1.save()
        v2 = Vacancy.objects.create(company=new_company, verified=True, open_time=open_time, salary=3500000,
                               description='', close_time=close_time, name='vacancy2', max_accepted_applicants=3,
                               working_period="3 Bulan", created=datetime(2018, 12, 10))
        v2.created = datetime(2018, 12, 10)
        v2.save()
        factory = APIRequestFactory()
        url_name_asc = '/api/vacancies/?sort=name&order=ascending'
        request = factory.get(url_name_asc)
        response = self.client.get(url_name_asc, format='json')
        self.assertEqual(dict(response.data)['results'], VacancySerializer(Vacancy.objects.order_by('name'), many=True,
                                                                           context={'request': request}).data)

        url_salary_asc = '/api/vacancies/?sort=salary'
        response = self.client.get(url_salary_asc)
        request = factory.get(url_salary_asc)
        self.assertEqual(dict(response.data)['results'],
                         VacancySerializer(Vacancy.objects.order_by('salary'), many=True,
                                           context={'request': request}).data)

        url_name_desc = '/api/vacancies/?sort=name&order=descending'
        response = self.client.get(url_name_desc)
        request = factory.get(url_name_desc)
        self.assertEqual(dict(response.data)['results'], VacancySerializer(Vacancy.objects.order_by('-name'), many=True,
                                                                           context={'request': request}).data)

        url_salary_desc = '/api/vacancies/?sort=salary&order=descending'
        response = self.client.get(url_salary_desc)
        request = factory.get(url_salary_desc)
        self.assertEqual(dict(response.data)['results'],
                         VacancySerializer(Vacancy.objects.order_by('-salary'), many=True,
                                           context={'request': request}).data)

        url_recent = '/api/vacancies/?sort=recent'
        response = self.client.get(url_recent)
        request = factory.get(url_recent)
        self.assertEqual(dict(response.data)['results'],
                         VacancySerializer(Vacancy.objects.order_by('-created'), many=True,
                                           context={'request': request}).data)

    def test_fail_on_unverified_user_vacancy_list(self):
        url = '/api/vacancies/'
        response = self.client.post(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_opened_only_vacancy_list(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        url = '/api/vacancies/?opened_only=true'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_opened_and_unopened_vacancy_list(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        self.client.force_authenticate(user=superuser)

        url = '/api/vacancies/?opened_only=false'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    @requests_mock.Mocker()
    def test_closed_vacancy_not_included(self, m):
        self.login(m)
        new_user = User.objects.create_user('dummy.company2', 'dummy.compan2y@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)
        Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(1541319300.0),
                               description="expired vacancy", close_time=datetime.fromtimestamp(1541319301.0),
                               max_accepted_applicants=3, working_period="3 Bulan")

        url = '/api/vacancies/?opened_only=true'
        response = self.client.get(url, format='json')
        self.assertEqual("expired vacancy" in response, False)

    def test_vacancy_is_closed(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_company = Company.objects.create(user=superuser, description="lalalaz", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", close_time=timezone.now() - timedelta(minutes=10),
                                             working_period="3 Bulan")
        self.client.force_authenticate(user=superuser)

        response = new_vacancy.apply_before

        self.assertEqual(response, "Pendaftaran ditutup")

    def test_vacancy_is_closed(self):
        superuser = User.objects.create_superuser('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_company = Company.objects.create(user=superuser, description="lalalaz", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", close_time=timezone.now() + timedelta(minutes=10),
                                             max_accepted_applicants=3, working_period="3 Bulan")
        self.client.force_authenticate(user=superuser)

        response = new_vacancy.apply_before

        self.assertNotEqual(response, "Pendaftaran ditutup")

    def test_vacancy_valid_date(self):
        self.assertEqual(True, date_validator(str(datetime.today() + timedelta(days=1)),
                                              str(datetime.today() + timedelta(days=2)))['is_valid'])

    def test_vacancy_invalid_date(self):
        self.assertEqual(
            status.HTTP_400_BAD_REQUEST,
            date_validator(str(datetime.today() - timedelta(days=1)), str(datetime.today()))['status'])

        self.assertEqual(status.HTTP_400_BAD_REQUEST,
                         date_validator(str(datetime.today()), str(datetime.today() - timedelta(days=1)))['status'])

        self.assertRaisesMessage(status.HTTP_400_BAD_REQUEST,
                                 date_validator(str(datetime.today()), str(datetime.today()))['status'])


class CompanyListsTests(APITestCase):
    def test_company_vacancy_list(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/vacancies/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_company_vacancy_list_unauthorized(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.companyzxc', 'dummy.companyzxc@company.com', 'lalala123')
        Company.objects.create(user=new_user2, description="lalalaasdsad", status=Company.VERIFIED,
                               logo=None,
                               address=None)

        self.client.force_authenticate(new_user2)

        url = '/api/companies/' + str(new_company.pk) + '/vacancies/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_company_application_list(self):
        new_user = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_company_application_list_with_status(self):
        new_user = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/?status=0'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_company_application_list_unauthorized(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.companyzxc', 'dummy.companyzxc@company.com', 'lalala123')
        Company.objects.create(user=new_user2, description="lalalaasdsad", status=Company.VERIFIED,
                               logo=None,
                               address=None)

        self.client.force_authenticate(new_user2)

        url = '/api/companies/' + str(new_company.pk) + '/applications/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_company_application_list_by_vacancy(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(new_vacancy.pk) + '/by_vacancy/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_company_application_list_by_vacancy_unauthorized_1(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.student', 'dummy.company3@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        new_user3 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        Company.objects.create(user=new_user3, description="lalala", status=Company.VERIFIED, logo=None,
                               address=None)

        self.client.force_authenticate(new_user3)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(new_vacancy.pk) + '/by_vacancy/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_company_application_list_by_vacancy_unauthorized_2(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.student', 'dummy.company3@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        new_user3 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_company3 = Company.objects.create(user=new_user3, description="lalala", status=Company.VERIFIED, logo=None,
                                              address=None)

        self.client.force_authenticate(new_user3)

        url = '/api/companies/' + str(new_company3.pk) + '/applications/' + str(new_vacancy.pk) + '/by_vacancy/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_company_application_list_by_vacancy_with_status(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(new_vacancy.pk) + '/by_vacancy/?status=2'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_company_application_list_by_vacancy_with_bad_status_string(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(
            new_vacancy.pk) + '/by_vacancy/?status=lalala'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_company_application_list_by_vacancy_with_bad_status_negative(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(
            new_vacancy.pk) + '/by_vacancy/?status=-1'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_company_application_list_by_vacancy_with_bad_status_large(self):
        new_user = User.objects.create_user('dummy.company3', 'dummy.company3@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_student = Student.objects.create(user=new_user2, npm=1234123412)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3,
                                             working_period="3 Bulan")
        Application.objects.create(student=new_student, vacancy=new_vacancy, cover_letter="asdasdasd")

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/' + str(new_vacancy.pk) + '/by_vacancy/?status=5'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_company_application_list_with_major(self):
        new_user = User.objects.create_user('dummy.company4', 'dummy.company4@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        self.client.force_authenticate(new_user)

        url = '/api/companies/' + str(new_company.pk) + '/applications/?major=0'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)


class SupervisorStudentApplicationTests(APITestCase):
    def test_list_student_application(self):
        new_user = User.objects.create_user('dummy.supervisor', 'dummy.supervisor@asd.asd', 'lalala123')
        Supervisor.objects.create(user=new_user, nip=1212121212)
        self.client.force_authenticate(user=new_user)

        url = '/api/applications/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_list_student_application_unauthorized(self):
        new_user = User.objects.create_user('dummy.supervisor', 'dummy.supervisor@asd.asd', 'lalala123')
        self.client.force_authenticate(user=new_user)

        url = '/api/applications/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)


class SupervisorApprovalTests(APITestCase):
    def test_supervisor_approve_vacancy(self):
        new_user = User.objects.create_user('dummy.supervisor', 'dummy.supervisor@asd.asd', 'lalala123')
        Supervisor.objects.create(user=new_user, nip=1212121212)
        self.client.force_authenticate(user=new_user)

        new_user2 = User.objects.create_user('dummy.company2', 'dummy.compan2y@company.com', 'lalala123')
        new_company2 = Company.objects.create(user=new_user2, description="lalala", status=Company.VERIFIED, logo=None,
                                              address=None)
        new_vacancy2 = Vacancy.objects.create(company=new_company2, verified=False,
                                              open_time=datetime.fromtimestamp(1541319300.0),
                                              description="lalala", requirements="requirements",
                                              close_time=timezone.now(), max_accepted_applicants=3)

        url = '/api/vacancies/' + str(new_vacancy2.pk) + '/verify/'
        response = self.client.patch(url, {'verified': True}, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        retrieve_vacancy = Vacancy.objects.get(pk=new_vacancy2.pk)
        self.assertEqual(retrieve_vacancy.verified, True)

    def test_unauthorized_approve_vacancy(self):
        new_user = User.objects.create_user('dummy.companyz', 'dummy.companyz@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalalaz", status=Company.VERIFIED, logo=None,
                                             address=None)
        self.client.force_authenticate(user=new_user)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=False,
                                             open_time=datetime.fromtimestamp(1541319300.0),
                                             description="lalala", requirements="requirements",
                                             close_time=timezone.now(), max_accepted_applicants=3)

        url = '/api/vacancies/' + str(new_vacancy.pk) + '/verify/'
        response = self.client.patch(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(new_vacancy.verified, False)


class ValidationPositionNameinCreateLowonganKP(APITestCase):
    def setUp(self):
        user = User.objects.create_user('dummy', 'dummy@dummy.com', 'dummy')
        self.client.force_authenticate(user=user)
        self.company = Company.objects.create(
            user=user,
            description="dummy",
            status=Company.VERIFIED,
            logo=None,
            address=None
        )
        self.url = '/api/vacancies/'
        self.payload = {
            "name": "dummy",
            "company": self.company.id,
            "open_time": datetime.today(),
            "close_time": datetime.today() + timedelta(days=10),
            "description": "dummy",
            "working_period": "Summer 2019",
            "max_accepted_applicants": 10,
        }
        self.message = "Name must alphabets only"

    def test_name_contains_only_alphabets(self):
        self.payload["name"] = "Engineer"
        self.payload["requirements"] = "lalala"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code

        self.assertEqual(response_status_code, 200)

    def test_name_contains_only_alphabets_and_spaces(self):
        self.payload["name"] = "Software Engineer"
        self.payload["requirements"] = "lala la"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code

        self.assertEqual(response_status_code, 200)

    def test_name_contains_alphabets_and_numerics(self):
        self.payload["name"] = "Software18 Engineer"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_name_contains_only_numerics(self):
        self.payload["name"] = "123654789"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_name_contains_characters_besides_alphabets(self):
        self.payload["name"] = "!@#$%^&*()"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_salary_contains_number_only(self):
        self.payload["salary"] = 2312312

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 200)

    def test_salary_contains_number_and_alphabet(self):
        self.payload["salary"] = "sdsaa"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_amount_contains_number_only(self):
        self.payload["amount"] = 231231

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 200)

    def test_max_accepted_applicants_contains_only_number(self):
        self.payload["max_accepted_applicants"] = "11"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 200)

    def test_max_accepted_applicants_contains_only_alphabet(self):
        self.payload["max_accepted_applicants"] = "abcd"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_max_accepted_applicants_contains_number_and_alphabet(self):
        self.payload["max_accepted_applicants"] = "a1r1"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)

    def test_amount_contains_number_and_alphabet(self):
        self.payload["salary"] = "sadas231"

        response = self.client.post(
            self.url,
            self.payload,
            format="json"
        )

        response_status_code = response.status_code
        self.assertEqual(response_status_code, 400)


class VacancyMilestoneTests(APITestCase):
    def setUp(self):
        super(VacancyMilestoneTests, self).setUp()
        self.user = User.objects.create_user('dummy.student', 'dummy.student@home.com', 'lalala123')
        self.company_user = User.objects.create_user('dummy.company2', 'dummy.compan2y@company.com', 'lalala123')
        self.company = Company.objects.create(user=self.company_user, description="lalala", status=Company.VERIFIED,
                                              logo=None,
                                              address=None)
        self.vacancy = Vacancy.objects.create(company=self.company, verified=True, open_time=datetime.fromtimestamp(0),
                                              description="lalala", close_time=datetime.today())

    def create_milestone_object(self):
        return VacancyMilestone.objects.create(vacancy=self.vacancy, name="initiate", detail="install things",
                                               expected_start=datetime.fromtimestamp(0),
                                               expected_finish=datetime.fromtimestamp(86400))

    def test_vacancy_milestone_model(self):
        milestone1 = VacancyMilestone(vacancy=self.vacancy, name="initiate", detail="install things",
                                      expected_start=datetime.fromtimestamp(0),
                                      expected_finish=datetime.fromtimestamp(86400))
        milestone1.full_clean()

        milestone2 = VacancyMilestone(vacancy=self.vacancy, name="a" * 101, detail="install things",
                                      expected_start=datetime.fromtimestamp(0),
                                      expected_finish=datetime.fromtimestamp(86400))
        with self.assertRaises(ValidationError, msg="Name with more than 100 character should raise ValidationError"):
            milestone2.full_clean()

        milestone3 = VacancyMilestone(vacancy=self.vacancy, name="initiate", detail="install things",
                                      expected_start=datetime.fromtimestamp(86400),
                                      expected_finish=datetime.fromtimestamp(0))
        with self.assertRaises(ValidationError, msg="Expected finish earlier than tart should raise ValidationError"):
            milestone3.full_clean()

    def test_vacancy_milestones_list(self):
        milestone1 = self.create_milestone_object()
        self.client.force_authenticate(user=self.user)

        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/'
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data["results"]), 1)
        self.assertEqual(response.data["results"][0]["name"], milestone1.name)
        self.assertEqual(response.data["results"][0]["detail"], milestone1.detail)

    def test_create_new_milestone_on_a_vacancy_success(self):
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/'
        data = {"name": "initiate", "detail": "install things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-21"}
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.vacancy.milestones.count(), 1)
        new_milestone = self.vacancy.milestones.first()
        self.assertEqual(new_milestone.name, data["name"])
        self.assertEqual(new_milestone.detail, data["detail"])

    def test_create_new_milestone_on_a_vacancy_invalid_data(self):
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/'
        data = {"name": "initiate", "detail": "install things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-01"}
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(self.vacancy.milestones.count(), 0)

    def test_create_new_milestone_on_a_vacancy_unauthorized_user(self):
        self.client.force_authenticate(user=self.user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/'
        data = {"name": "initiate", "detail": "install things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-21"}
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(self.vacancy.milestones.count(), 0)

    def test_modify_milestone_on_a_vacancy_success(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/' + str(milestone.pk) + '/'
        data = {"name": "initiate env", "detail": "install all things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-21"}
        response = self.client.put(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.vacancy.milestones.count(), 1)
        new_milestone = self.vacancy.milestones.first()
        self.assertEqual(new_milestone.name, data["name"])
        self.assertEqual(new_milestone.detail, data["detail"])

    def test_modify_milestone_on_a_vacancy_not_found(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/1000/milestones/' + str(milestone.pk) + '/'
        data = {"name": "initiate env", "detail": "install all things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-21"}
        response = self.client.put(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
        url2 = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/1000/'
        response2 = self.client.put(url2, data, format='json')
        self.assertEqual(response2.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(self.vacancy.milestones.count(), 1)
        new_milestone = self.vacancy.milestones.first()
        self.assertEqual(new_milestone.name, milestone.name)
        self.assertEqual(new_milestone.detail, milestone.detail)

    def test_modify_milestone_on_a_vacancy_invalid_data(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/' + str(milestone.pk) + '/'
        data = {"name": "a" * 101, "detail": "install all things", "expected_start": "2019-01-21",
                "expected_finish": "2019-01-19"}
        response = self.client.put(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(self.vacancy.milestones.count(), 1)
        new_milestone = self.vacancy.milestones.first()
        self.assertEqual(new_milestone.name, milestone.name)
        self.assertEqual(new_milestone.detail, milestone.detail)

    def test_modify_milestone_on_a_vacancy_unauthorized_user(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/' + str(milestone.pk) + '/'
        data = {"name": "initiate env", "detail": "install all things", "expected_start": "2019-01-20",
                "expected_finish": "2019-01-21"}
        response = self.client.put(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(self.vacancy.milestones.count(), 1)
        new_milestone = self.vacancy.milestones.first()
        self.assertEqual(new_milestone.name, milestone.name)
        self.assertEqual(new_milestone.detail, milestone.detail)

    def test_delete_milestone_on_a_vacancy_success(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/' + str(milestone.pk) + '/'
        response = self.client.delete(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.vacancy.milestones.count(), 0)

    def test_delete_milestone_on_a_vacancy_not_found(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.company_user)
        url = '/api/vacancies/1000/milestones/' + str(milestone.pk) + '/'
        response = self.client.delete(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
        url2 = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/1000/'
        response2 = self.client.delete(url2, format='json')
        self.assertEqual(response2.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(self.vacancy.milestones.count(), 1)

    def test_delete_milestone_on_a_vacancy_unauthorized_user(self):
        milestone = self.create_milestone_object()
        self.client.force_authenticate(user=self.user)
        url = '/api/vacancies/' + str(self.vacancy.pk) + '/milestones/' + str(milestone.pk) + '/'
        response = self.client.delete(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(self.vacancy.milestones.count(), 1)


class AcceptOneOfferTests(APITestCase):
    def generateObject(self):
        new_user = User.objects.create_user('dummy.company', 'dummy.company@company.com', 'lalala123')
        new_company = Company.objects.create(user=new_user, description="lalala", status=Company.VERIFIED, logo=None,
                                             address=None)

        new_user2 = User.objects.create_user('dummy.company2', 'dummy.company2@company.com', 'lalala123')
        new_company2 = Company.objects.create(user=new_user2, description="lalala", status=Company.VERIFIED, logo=None,
                                              address=None)

        new_vacancy = Vacancy.objects.create(company=new_company, verified=True, open_time=datetime.fromtimestamp(0),
                                             description="lalala", requirements="requirements",