def test_match_expectation_does_not_raise_when_correct_command_comes_excludes(self):
        """
        test_match_expectation_does_not_raise_when_correct_command_comes_excludes

        Given:
            - there is an expectation with crmrequestfactory.EXCLUDES
        When:
            - request_handler.match_expectation() is called with the next expected command in the queue
        Then:
            - no error is raised
        """

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                ARBITRARY_STUDENT_ID,
                {
                    crmrequestfactory.EXCLUDES: {
                        u"commaseparated_list": u"epsilon, phi, khi"
                    }
                }
            ),
            {u"fake": u"fake"}
        )

        self.request_handler.match_expectation(
            crmrequestfactory.set_project_data(
                ARBITRARY_STUDENT_ID,
                {
                    u"commaseparated_list": u"alpha, beta, gamma, delta"
                }
            )
        )
    def test_match_expectation_raises_when_incorrect_command_comes_excludes(self):
        """
        test_match_expectation_raises_when_incorrect_command_comes_excludes

        Given:
            - there is an expectation with crmrequestfactory.EXCLUDES
        When:
            - request_handler.match_expectation() is called with the next expected command in the queue, which doesn't
            contxclude all required elements
        Then:
            - AssertionError is raised
        """

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                ARBITRARY_STUDENT_ID,
                {
                    crmrequestfactory.EXCLUDES: {
                        u"commaseparated_list": u"alpha, epsilon, phi, khi"
                    }
                }
            ),
            {u"fake": u"fake"}
        )

        with self.assertRaisesRegexp(AssertionError, "Unexpected command") as cm:
            self.request_handler.match_expectation(
                crmrequestfactory.set_project_data(
                    ARBITRARY_STUDENT_ID,
                    {
                        u"commaseparated_list": u"alpha, beta, gamma, delta"
                    }
                )
            )
    def test_student_is_applied_headcount_is_less_than_the_limit_put_student_to_infosent_update_headcounts_copy_course_data(
            self):
        """
        test_student_is_applied_headcount_is_less_than_the_limit_put_student_to_infosent_update_headcounts_copy_course_data

        Given:
            - one beginner student is in applied ("Jelentkezett") state
            - current headcount is less than maximal headcount. (there is at least one free spot) in the wanted course.)
        When:
            - register_new_applicants() is called
        Then:
            - student's info is filled
            - student is put to INFO sent ("INFO level kiment") state
            - beginner INFO mail is sent
            - application deadline is set
            - headcount is updated
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                NEW_APPLICANT_STATUS_NUMBER),
            responses_studentlists.NEW_APPLICANTS_ONE_STUDENT)
        self.set_participant_number_expectations()

        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT_ZERO_MAILS)

        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"TanfolyamKodja": u"2019-1-Q"}),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(
                LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME)
        self.request_handler.expect_request(
            crmrequestfactory.get_location(LOCATION_ID),
            responses_locations.PANNON_KINCSTAR)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_OTHER_ID_NUMBER,
                                               crmrequestfactory._),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER, {
                    u"StatusId": u"2781",
                    u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"
                }), responses_general.XPUT_RESPONSE)
        register_new_applicants(self.crm_facade)
    def test_there_is_one_student_on_waiting_list_and_there_is_one_free_place_put_student_to_info_sent(
            self):
        """
        test_there_is_one_student_on_waiting_list_and_there_is_one_free_place_put_student_to_info_sent

        Given:
            - there is a student in waiting list
            - there is one free spot on the wanted course
        When:
            - handle_waiting_list() is called
        Then:
            - INFO email is sent
            - "A spot freed up" email is sent
            - change student's status to "INFO sent"
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                WAITING_LIST_STATUS_NUMBER),
            responses_studentlists.WAITING_LIST_ONE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"Levelkuldesek": u"Felszabadult egy hely"}),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(
                LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME)
        self.request_handler.expect_request(
            crmrequestfactory.get_location(FAKE_LOCATION_ID),
            responses_locations.PANNON_KINCSTAR)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_OTHER_ID_NUMBER,
                                               crmrequestfactory._),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER, {
                    "StatusId": "2781",
                    crmrequestfactory.CONTAINS: {
                        u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"
                    }
                }), responses_general.XPUT_RESPONSE)
        self.set_participant_number_expectations()
        handle_waiting_list(self.crm_facade)
    def test_online_frontend_student_is_applied_headcount_is_not_less_than_the_limit_put_student_to_waiting_list_and_send_mail(
            self):
        """
        test_online_frontend_student_is_applied_headcount_is_not_less_than_the_limit_put_student_to_waiting_list_and_send_mail

        Given:
            - one frontend student is in applied ("Jelentkezett") state
            - current headcount is equal to maximal headcount. (there is no free spot in the wanted course.)
        When:
            - register_new_applicants() is called
        Then:
            - student is put to waiting list ("Varolistan van") state
            - waiting list mail is sent
            - headcount is updated
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                NEW_APPLICANT_STATUS_NUMBER),
            responses_studentlists.NEW_APPLICANTS_ONE_STUDENT)
        self.set_participant_number_expectations()

        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT_ONLINE_FRONTEND_ZERO_MAILS)

        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONLINE_FRONTEND_FULL)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"TanfolyamKodja": u"2019-1-Q"}),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER, {
                    u"StatusId": u"2750",
                    crmrequestfactory.CONTAINS: {
                        u"Levelkuldesek": u"V\u00e1r\u00f3lista"
                    }
                }), responses_general.XPUT_RESPONSE)

        register_new_applicants(self.crm_facade)
    def test_in_progress_first_day_is_spent_but_last_didnt_set_state_to_in_progress(self):
        """
        test_in_progress_first_day_is_spent_but_last_didnt_set_state_to_in_progress

        Given:
            - One course is in In Progress state ("Folyamatban")
            - First day has spent, last day hasn't
        When:
            - set_course_states() is called
        Then:
            - Course is put to In Progress ("Folyamatban") state
        """

        self.crm_facade.set_today(datetime.datetime(2019, 1, 29, 7, 30))
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(IN_PROGRESS_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(RECENTLY_FINISHED_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_IN_PROGRESS)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"StatusId": u"2758"}),
            responses_general.XPUT_RESPONSE)
        set_course_states(self.crm_facade)
    def test_last_day_is_missing_no_error_is_raised_put_to_in_progress(self):
        """
        test_last_day_is_missing_no_error_is_raised_put_to_in_progress

        Given:
            - One course is in in Application open ("Jelentkezes nyitva") state
            - Last day is missing
        When:
            - set_course_states() is called
        Then:
            - Error is not raised
            - Course is put to In Progress ("Folyamatban") state
        """

        self.crm_facade.set_today(datetime.datetime(2019, 5, 15, 7, 30))
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(IN_PROGRESS_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(RECENTLY_FINISHED_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_LAST_DATE_MISSING)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"StatusId": u"2758"}),
            responses_general.XPUT_RESPONSE)
        set_course_states(self.crm_facade)
    def test_recently_finished_and_35_days_passed_put_to_closed(self):
        """
        test_recently_finished_and_35_days_passed_put_to_closed

        Given:
            - One course is in In Progress state ("Folyamatban")
            - Last day has spent more than 35 days ago
        When:
            - set_course_states() is called
        Then:
            - Course is put to Closed ("Vegzett") state
        """

        self.crm_facade.set_today(datetime.datetime(2019, 5, 15, 7, 30))
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(IN_PROGRESS_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(RECENTLY_FINISHED_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_RECENTLY_FINISHED)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"StatusId": u"2754"}),
            responses_general.XPUT_RESPONSE)
        set_course_states(self.crm_facade)
    def test_recently_finished_last_day_has_spent_but_not_35_more_put_to_recently_finished(self):
        """
        test_recently_finished_last_day_has_spent_but_not_35_more_put_to_recently_finished

        Given:
            - One course is in Recently Finished state ("Frissen vegzett")
            - Last day has spent, but not more than 35 days ago
        When:
            - set_course_states() is called
        Then:
            - Course is put to Recently Finished ("Frissen vegzett") state
        """

        self.crm_facade.set_today(datetime.datetime(2019, 4, 9, 7, 30))
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(IN_PROGRESS_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(RECENTLY_FINISHED_STATUS_NUMBER),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_RECENTLY_FINISHED)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"StatusId": u"2797"}),
            responses_general.XPUT_RESPONSE)
        set_course_states(self.crm_facade)
Exemplo n.º 10
0
    def test_there_are_2_info_sent_3_active_2_waiting_list_1_did_not_answer_1_spectator_count_is_set_to_5(self):
        """
        Given:
            - there is one course in Application Open ("Jelentkezes nyitva") state
            - there are 2 info sent students registered to this course
            - there are 3 active students registered to this course
            - there are 2 waiting list students registered to this course
            - there is 1 did not answer student registered to this course
            - there is 1 spectator student registered to this course
        When:
            - update_headcounts() is called
        Then:
            - headcount is updated to 5
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_0_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_studentlists.COMPLEX_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"AktualisLetszam": 5}),
            responses_general.XPUT_RESPONSE)
        self.crm_facade.update_headcounts()
Exemplo n.º 11
0
    def test_headcount_is_2_when_there_are_no_students_for_this_course_count_is_set_to_0(self):
        """
        Given:
            - there is one course in Application Open ("Jelentkezes nyitva") state
            - current headcount is 2
            - no students applied to this course
        When:
            - update_headcounts() is called
        Then:
            - headcount is updated to 0
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_2_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_general.EMPTY_LIST)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"AktualisLetszam": 0}),
            responses_general.XPUT_RESPONSE)
        self.crm_facade.update_headcounts()
Exemplo n.º 12
0
    def test_headcount_is_0_when_there_is_1_info_sent_student_and_noone_else_count_is_set_to_1(self):
        """
        Given:
            - there is one course in Application Open ("Jelentkezes nyitva") state
            - current headcount is 0
            - there is 1 info sent student registered to the course
        When:
            - update_headcounts() is called
        Then:
            - headcount is updated to 1
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_0_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_studentlists.INFO_SENT_ONE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"AktualisLetszam": 1}),
            responses_general.XPUT_RESPONSE)
        self.crm_facade.update_headcounts()
Exemplo n.º 13
0
    def set_participant_number_expectations(self):
        """
        Sets expectations for the update_headcounts() method of CrmFacade.

        CrmFacade's update_headcounts() is a commonly used method, which creates a typical pattern of API requests. This
        pattern has to be expected again and again in every test which uses the update_headcounts() method, maybe
        multiple times in a use case. This method provides a single line to set those expectations, and also logically
        group these expectations, and make the code easier to read.
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                COURSE_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_project(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_studentlists.COURSE_CODE_IS_2019_1_Q)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER,
                                               {u"AktualisLetszam": 6}),
            responses_general.XPUT_RESPONSE)
Exemplo n.º 14
0
    def test_copy_applied_course_to_course_code(self):
        """
        Copy applied course to course code

        Given:
            - there is a student with different applied to and course code
        When:
            - copy_applied_course_to_course_code is called with that student
        Then:
            - The applied to course is copied to the course code field of the student
        """
        id_field = u"Id"
        applied_to_field = u"MelyikTanfolyamErdekli"
        course_code_field = u"TanfolyamKodja"

        student_id = responses_studens.FAKE_STUDENT_COURSE_CODE_AND_APPLIED_TO_ARE_DIFFERENT[id_field]
        applied_to = responses_studens.FAKE_STUDENT_COURSE_CODE_AND_APPLIED_TO_ARE_DIFFERENT[applied_to_field]

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                student_id,
                {
                    course_code_field: applied_to
                }
            ),
            responses_general.XPUT_RESPONSE
        )

        self.crm_facade.copy_applied_course_to_course_code(
            responses_studens.FAKE_STUDENT_COURSE_CODE_AND_APPLIED_TO_ARE_DIFFERENT)
    def expect_register_new_applicants(self):
        """Sets up expectations to a valid registernewapplicants workflow"""
        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(NEW_APPLICANT_STATUS_NUMBER),
            responses_studentlists.NEW_APPLICANTS_ONE_STUDENT)
        self.set_participant_number_expectations()

        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT)

        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE
        )
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE
        )
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"TanfolyamKodja": u"2019-1-Q"}
            ),
            responses_general.XPUT_RESPONSE
        )
        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME
        )

        self.request_handler.expect_request(
            crmrequestfactory.get_location(LOCATION_ID),
            responses_locations.PANNON_KINCSTAR
        )
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_OTHER_ID_NUMBER, crmrequestfactory._),
            responses_general.XPUT_RESPONSE
        )
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"StatusId": u"2781", u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"}
            ),
            responses_general.XPUT_RESPONSE
        )
    def test_match_expectation_raises_when_incorrect_command_comes_includes_excludes_wrong_exact_match(self):
        """
        test_match_expectation_raises_when_incorrect_command_comes_contains

        Given:
            - there is an expectation with mixed crmrequestfactory.EXCLUDES, CONTAINS and exact match
        When:
            - request_handler.match_expectation() is called with the next expected command in the queue, with wrong
            exact match
        Then:
            - AssertionError is raised
        """

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                ARBITRARY_STUDENT_ID,
                {
                    u"exact_match": u"exact_element",
                    crmrequestfactory.CONTAINS: {
                        u"commaseparated_list": u"alpha, beta"
                    },
                    crmrequestfactory.EXCLUDES: {
                        u"commaseparated_list": u"epsilon, phi, khi"
                    }
                }
            ),
            {u"fake": u"fake"}
        )

        with self.assertRaisesRegexp(AssertionError, "Unexpected command") as cm:
            self.request_handler.match_expectation(
                crmrequestfactory.set_project_data(
                    ARBITRARY_STUDENT_ID,
                    {
                        u"exact_match": u"exact_element_wrong",
                        u"commaseparated_list": u"alpha, beta, gamma, delta"
                    }
                )
            )
    def expect_clean_info_sent(self):
        """Sets up expectations to a valid cleaninfosent workflow"""
        self.crm_facade.set_today(datetime.datetime(2019, 1, 22, 12, 0))

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(INFO_SENT_STATUS_NUMBER),
            responses_studentlists.INFO_SENT_ONE_STUDENT)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_ID_NUMBER,
                {u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l, Egy napod van jelentkezni"}
            ),
            responses_general.XPUT_RESPONSE
        )

        self.set_participant_number_expectations()
Exemplo n.º 18
0
    def test_student_did_not_finalize_deadline_has_spent_more_than_24_hours_ago_delete(
            self):
        """
        test_student_did_not_finalize_deadline_has_spent_more_than_24_hours_ago_delete

        Given:
            - there is a student in INFO sent ("INFO level kiment") state
            - they did not finalize application
            - finalization deadline has been spent more than 24 hours ago
        When:
            - clean_info_sent() is called
        Then:
            - "we deleted you" email is sent
            - status of student is set to deleted
        """

        self.crm_facade.set_today(datetime.datetime(2019, 1, 24, 12, 0))

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                INFO_SENT_STATUS_NUMBER),
            responses_studentlists.INFO_SENT_ONE_STUDENT)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_ID_NUMBER, {
                    u"StatusId":
                    u"2782",
                    u"Levelkuldesek":
                    u"Kezd\u0151 INFO lev\u00e9l, Egy napod van jelentkezni, Ma kell jelentkezni, Toroltunk"
                }), responses_general.XPUT_RESPONSE)

        self.set_participant_number_expectations()

        clean_info_sent(self.crm_facade)
Exemplo n.º 19
0
    def test_student_did_not_finalize_deadline_has_spent_but_not_more_than_24_hours_ago_send_reminder_raise_task(
            self):
        """
        test_student_did_not_finalize_deadline_has_spent_but_not_more_than_24_hours_ago_send_reminder_raise_task

        Given:
            - there is a student in INFO sent ("INFO level kiment") state
            - they did not finalize application
            - finalization deadline has been spent, but is within less than 24 hours
        When:
            - clean_info_sent() is called
        Then:
            - 2nd reminder email ("Egy napod van jelentkezni") is sent
            - task is raised on the student
        """

        self.crm_facade.set_today(datetime.datetime(2019, 1, 23, 12, 0))

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                INFO_SENT_STATUS_NUMBER),
            responses_studentlists.INFO_SENT_ONE_STUDENT)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_ID_NUMBER, {
                    u"Levelkuldesek":
                    u"Kezd\u0151 INFO lev\u00e9l, Egy napod van jelentkezni, Ma kell jelentkezni"
                }), responses_general.XPUT_RESPONSE)

        self.set_participant_number_expectations()

        clean_info_sent(self.crm_facade)
Exemplo n.º 20
0
    def test_there_is_1_student_in_did_not_answer_count_is_set_to_0(self):
        """
        Given:
            - there is one course in Application Open ("Jelentkezes nyitva") state
            - there is 1 student in "Did not finalize" ("Nem jelzett vissza") state
        When:
            - update_headcounts() is called
        Then:
            - headcount is updated to 0
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_0_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_studentlists.DID_NOT_ANSWER_ONE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"AktualisLetszam": 0}),
            responses_general.XPUT_RESPONSE)
        self.crm_facade.update_headcounts()
Exemplo n.º 21
0
    def test_there_is_1_student_in_unsubscribed_is_set_to_0(self):
        """
        Given:
            - there is one course in Application Open ("Jelentkezes nyitva") state
            - there is 1 student in Unsubscribed ("Leiratkozott") state
        When:
            - update_headcounts() is called
        Then:
            - headcount is updated to 0
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(APPLICATION_OPEN_STATUS_NUMBER),
            responses_courselists.LIST_OF_OPEN_COURSES_2753_ONE_COURSE_OPEN)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_0_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(FAKE_COURSE_COURSE_CODE),
            responses_studentlists.UNSUBSCRIBED_ONE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_COURSE_ID_NUMBER, {u"AktualisLetszam": 0}),
            responses_general.XPUT_RESPONSE)
        self.crm_facade.update_headcounts()
    def test_student_gets_into_chosen_course_even_if_available_courses_changed(
            self):
        """
        test_student_gets_into_chosen_course_even_if_available_courses_changed

        Given:
            - there is a student in waiting list
            - MelyikTanfolyamErdekli and TanfolyamKodja are different
            - there is one free spot on the wanted course
        When:
            - handle_waiting_list() is called
        Then:
            - INFO email is sent
            - "A spot freed up" email is sent
            - change student's status to "INFO sent"
            - TanfolyamKodja is considered
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                WAITING_LIST_STATUS_NUMBER),
            responses_studentlists.WAITING_LIST_ONE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.
            FAKE_STUDENT_COURSE_CODE_AND_APPLIED_TO_ARE_DIFFERENT)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"Levelkuldesek": u"Felszabadult egy hely"}),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(
                LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME)
        self.request_handler.expect_request(
            crmrequestfactory.get_location(FAKE_LOCATION_ID),
            responses_locations.PANNON_KINCSTAR)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_OTHER_ID_NUMBER,
                                               crmrequestfactory._),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER, {
                    "StatusId": "2781",
                    crmrequestfactory.CONTAINS: {
                        u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"
                    }
                }), responses_general.XPUT_RESPONSE)

        self.set_participant_number_expectations()
        handle_waiting_list(self.crm_facade)
    def test_there_are_5_students_on_the_waiting_list_and_there_are_two_free_places_put_the_earliest_two_to_info_sent(
            self):
        """
        test_there_are_5_students_on_the_waiting_list_and_there_are_two_free_places_put_the_earliest_two_to_info_sent

        Given:
            - there are 5 students in waiting list
            - there are two free spots on the wanted course
        When:
            - handle_waiting_list() is called
        Then:
            - for the two who applied the earliest:
                - INFO email is sent
                - "A spot freed up" email is sent
                - change student's status to "INFO sent"
            - for the other student:
                - do nothing
        """

        self.request_handler.expect_request(
            crmrequestfactory.get_project_list_for_status(
                WAITING_LIST_STATUS_NUMBER),
            responses_studentlists.WAITING_LIST_FIVE_STUDENTS)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_FIFTH_ID_NUMBER),
            responses_students.FAKE_STUDENT)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_ID_NUMBER),
            responses_students.FAKE_STUDENT_APPLIED_LATER)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_SIXTH_ID_NUMBER),
            responses_students.FAKE_STUDENT_APPLIED_LATER)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(
                FAKE_STUDENT_APPLIED_LATER_ID_NUMBER),
            responses_students.FAKE_STUDENT_4TH_APPLIED)
        self.request_handler.expect_request(
            crmrequestfactory.get_student(FAKE_STUDENT_FOURTH_ID_NUMBER),
            responses_students.FAKE_STUDENT_5TH_APPLIED)

        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER,
                {u"Levelkuldesek": u"Felszabadult egy hely"}),
            responses_general.XPUT_RESPONSE)

        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(
                LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME)
        self.request_handler.expect_request(
            crmrequestfactory.get_location(FAKE_LOCATION_ID),
            responses_locations.PANNON_KINCSTAR)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_OTHER_ID_NUMBER,
                                               crmrequestfactory._),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_OTHER_ID_NUMBER, {
                    u"StatusId": u"2781",
                    crmrequestfactory.CONTAINS: {
                        u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"
                    }
                }), responses_general.XPUT_RESPONSE)

        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_ONE_PLACE_FREE)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_THIRD_ID_NUMBER,
                {u"Levelkuldesek": u"Felszabadult egy hely"}),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.get_location_list_by_location_name(
                LOCATION_NAME),
            responses_locationlists.LOCATION_LIST_FOR_LOCATION_NAME)
        self.request_handler.expect_request(
            crmrequestfactory.get_location(FAKE_LOCATION_ID),
            responses_locations.PANNON_KINCSTAR)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(FAKE_STUDENT_THIRD_ID_NUMBER,
                                               crmrequestfactory._),
            responses_general.XPUT_RESPONSE)
        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(
                FAKE_STUDENT_THIRD_ID_NUMBER, {
                    u"StatusId": u"2781",
                    crmrequestfactory.CONTAINS: {
                        u"Levelkuldesek": u"Kezd\u0151 INFO lev\u00e9l"
                    }
                }), responses_general.XPUT_RESPONSE)

        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_FULL)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_FULL)
        self.set_participant_number_expectations()
        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(
                FAKE_COURSE_COURSE_CODE),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)
        self.request_handler.expect_request(
            crmrequestfactory.get_course(FAKE_COURSE_ID_NUMBER),
            responses_courses.COURSE_2019_1_Q_FULL)

        self.set_participant_number_expectations()
        handle_waiting_list(self.crm_facade)
    def test_correct_list_of_students_is_updated_with_correct_data(self):
        """
        Correct list is updated by update_course_dates_for_all_students_for_that_course with correct data.

        Given:
            - 2 students applied to given course (regardless of their states)
        When:
            - update_course_dates_for_all_students_for_that_course is called
        Then:
            - both students are updated with the correct data (dates, dayoffs and date descriptions)
        """
        course_code = "2019-1-Q"
        course_id = 1164
        first_student_id = 2790
        second_student_id = 2796

        expected_data_to_update = {
            "N1Alkalom":
            "2019-01-28 23:59:59",
            "N2Alkalom2":
            "2019-02-04 23:59:59",
            "N3Alkalom2":
            "2019-02-11 23:59:59",
            "N4Alkalom2":
            "2019-02-18 23:59:59",
            "N5Alkalom2":
            "2019-02-25 23:59:59",
            "N6Alkalom2":
            "2019-03-04 23:59:59",
            "N7Alkalom2":
            "2019-03-18 23:59:59",
            "N8Alkalom2":
            "2019-03-25 23:59:59",
            "N9Alkalom2":
            "2019-04-01 23:59:59",
            "N10Alkalom2":
            "2019-04-08 23:59:59",
            "N2SzunetOpcionalis2":
            "2019-03-11 23:59:59",
            "N2SzunetOpcionalis3":
            "",
            "N3SzunetOpcionalis2":
            "",
            "Datumleirasok":
            "   - 2019-01-28\n   - 2019-02-04\n   - 2019-02-11\n   - 2019-02-18\n   - 2019-02-25\n   - 2019-03-04\n   - 2019-03-11 - szünet\n   - 2019-03-18\n   - 2019-03-25\n   - 2019-04-01\n   - 2019-04-08",
        }

        self.request_handler.expect_request(
            crmrequestfactory.get_course_list_by_course_code(course_code),
            responses_courselists.COURSE_LIST_FOR_COURSE_CODE)

        self.request_handler.expect_request(
            crmrequestfactory.get_course(course_id),
            responses_courses.COURSE_2019_1_Q)

        self.request_handler.expect_request(
            crmrequestfactory.get_student_list_by_course_code(course_code),
            responses_studentlists.WAITING_LIST_TWO_STUDENTS)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(first_student_id,
                                               expected_data_to_update),
            responses_general.XPUT_RESPONSE)

        self.request_handler.expect_request(
            crmrequestfactory.set_project_data(second_student_id,
                                               expected_data_to_update),
            responses_general.XPUT_RESPONSE)

        update_course_dates_for_all_students_for_that_course(
            self.crm_facade, course_code)