openedx-platform/cms/djangoapps/contentstore/api/tests/test_validation.py at 30d292da51e5896c653e5a0fef53bc87c82ef830 · openedx/openedx-platform · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
"""
Tests for the course import API views
"""

import factory
from datetime import datetime
from django.conf import settings

import ddt
from django.test.utils import override_settings
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITestCase
from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory, BlockFactory

from common.djangoapps.course_modes.models import CourseMode
from common.djangoapps.course_modes.tests.factories import CourseModeFactory
from common.djangoapps.student.tests.factories import StaffFactory
from common.djangoapps.student.tests.factories import UserFactory


@ddt.ddt
@override_settings(PROCTORING_BACKENDS={'DEFAULT': 'proctortrack', 'proctortrack': {}})
class CourseValidationViewTest(SharedModuleStoreTestCase, APITestCase):
    """
    Test course validation view via a RESTful API
    """
    @classmethod
    def setUpClass(cls):
        super().setUpClass()

        cls.course = CourseFactory.create(
            display_name='test course',
            run="Testing_course",
            proctoring_provider='proctortrack',
            proctoring_escalation_email='[email protected]',
        )
        cls.course_key = cls.course.id

        cls.password = 'test'
        cls.student = UserFactory(username='dummy', password=cls.password)
        cls.staff = StaffFactory(course_key=cls.course.id, password=cls.password)

        cls.initialize_course(cls.course)

    @classmethod
    def initialize_course(cls, course):
        """
        Sets up test course structure.
        """
        course.start = datetime.now()
        course.self_paced = True
        cls.store.update_item(course, cls.staff.id)

        update_key = course.id.make_usage_key('course_info', 'updates')
        cls.store.create_item(
            cls.staff.id,
            update_key.course_key,
            update_key.block_type,
            block_id=update_key.block_id,
            fields=dict(data="<ol><li><h2>Date</h2>Hello world!</li></ol>"),
        )

        section = BlockFactory.create(
            parent_location=course.location,
            category="chapter",
        )
        BlockFactory.create(
            parent_location=section.location,
            category="sequential",
        )

    def get_url(self, course_id):
        """
        Helper function to create the url
        """
        return reverse(
            'courses_api:course_validation',
            kwargs={
                'course_id': course_id,
            }
        )

    def test_student_fails(self):
        self.client.login(username=self.student.username, password=self.password)
        resp = self.client.get(self.get_url(self.course_key))
        self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)

    @ddt.data(
        (False, False),
        (True, False),
        (False, True),
        (True, True),
    )
    @ddt.unpack
    def test_staff_succeeds(self, certs_html_view, with_modes):
        features = dict(settings.FEATURES, CERTIFICATES_HTML_VIEW=certs_html_view)
        with override_settings(FEATURES=features):
            if with_modes:
                CourseModeFactory.create_batch(
                    2,
                    course_id=self.course.id,
                    mode_slug=factory.Iterator([CourseMode.AUDIT, CourseMode.VERIFIED]),
                )
            self.client.login(username=self.staff.username, password=self.password)
            resp = self.client.get(self.get_url(self.course_key), {'all': 'true'})
            self.assertEqual(resp.status_code, status.HTTP_200_OK)
            expected_data = {
                'assignments': {
                    'total_number': 1,
                    'total_visible': 1,
                    'assignments_with_dates_before_start': [],
                    'assignments_with_dates_after_end': [],
                    'assignments_with_ora_dates_after_end': [],
                    'assignments_with_ora_dates_before_start': [],
                },
                'dates': {
                    'has_start_date': True,
                    'has_end_date': False,
                },
                'updates': {
                    'has_update': True,
                },
                'certificates': {
                    'is_enabled': with_modes,
                    'is_activated': False,
                    'has_certificate': False,
                },
                'grades': {
                    'has_grading_policy': False,
                    'sum_of_weights': 1.0,
                },
                'proctoring': {
                    'needs_proctoring_escalation_email': True,
                    'has_proctoring_escalation_email': True,
                },
                'is_self_paced': True,
            }
            self.assertDictEqual(resp.data, expected_data)