def test_api_course_run_sync_with_no_update_fields(self, mock_signal):
"""
If a course run exists and LMS Backend has course run protected fields,
these fields should not be updated.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX")
course_run = CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_draft")
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
origin_data = SyncCourseRunSerializer(instance=course_run).data
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 12345,
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 9ef5f30f16ec0abe3cf2bd37a56f38f707e6467d91485e9c13f21eca606236b1"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check that the draft course run was updated except protected fields
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
no_update_fields = getattr(
settings,
"RICHIE_LMS_BACKENDS")[0].get("COURSE_RUN_SYNC_NO_UPDATE_FIELDS")
for field in draft_serializer.fields:
if field in no_update_fields:
self.assertEqual(draft_serializer.data[field],
origin_data[field])
else:
self.assertEqual(draft_serializer.data[field], data[field])
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DIRTY,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_existing_published_sync_to_draft(
self, mock_signal):
"""
If a course run exists in "sync_to_draft" mode (draft and public versions),
only the draft version should be udpated and the related course page should
be marked dirty.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX")
course_run = CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_draft")
course.extended_object.publish("en")
course.refresh_from_db()
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
origin_data = SyncCourseRunSerializer(instance=course_run).data
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 338f7c262254e8220fea54467526f8f1f4562ee3adf1e3a71abaf23a20b739e4"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 2)
# Check that the draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
# Check that the public course run was NOT updated
public_course_run = CourseRun.objects.get(
direct_course=course.public_extension)
public_serializer = SyncCourseRunSerializer(instance=public_course_run)
self.assertEqual(public_serializer.data, origin_data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DIRTY,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_existing_draft_with_public_course_sync_to_public(
self, mock_signal):
"""
If a course run exists in "sync_to_public" mode (only draft version),
but the course exists in public version, it should be updated, and a new public
version should be created.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX", should_publish=True)
CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_public")
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 103123,
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 a621d3394a9710642398edbd5b5d8670474d31c8d66f8baca5387a57ea7a854c"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 2)
# Check that the draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
# Check that a new public course run was created
public_course_run = CourseRun.objects.get(
direct_course=course.public_extension)
public_serializer = SyncCourseRunSerializer(instance=public_course_run)
self.assertEqual(public_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.assert_called_once_with(sender=Page,
instance=course.extended_object,
language=None)
def test_api_course_run_sync_create_sync_to_public_published_course(
self, mock_signal):
"""
If the submitted data is not related to an existing course run, a new course run should
be created. If the related course has a public counterpart, the synchronization is
applied a draft and a public course run.
"""
course = CourseFactory(code="DemoX", should_publish=True)
data = {
"resource_link":
"http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/",
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 324,
"catalog_visibility": "course_and_search",
}
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 8e232f3a6071a10cded2740bdc71aed06aa637719d28f968c7b7d35eccd765f7"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 2)
# Check the new draft course run
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
# Check the new public course run
public_course_run = CourseRun.objects.get(
direct_course=course.public_extension)
public_serializer = SyncCourseRunSerializer(instance=public_course_run)
self.assertEqual(public_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.assert_called_once_with(sender=Page,
instance=course.extended_object,
language=None)
def test_api_course_run_sync_existing_partial(self, mock_signal):
"""
If a course run exists, it can be partially updated and the other fields should not
be altered.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX")
course_run = CourseRunFactory(
direct_course=course, resource_link=link, sync_mode="sync_to_draft"
)
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
origin_data = SyncCourseRunSerializer(instance=course_run).data
data = {"resource_link": link, "end": "2021-03-14T09:31:59.417895Z"}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=(
"SIG-HMAC-SHA256 1de9b46133a91eec3515d0df40f586b642cff16b79aa9d5fe4f7679a33767967"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check that the draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data["end"], data["end"])
for field in draft_serializer.fields:
if field == "end":
continue
self.assertEqual(draft_serializer.data[field], origin_data[field])
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DIRTY,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_existing_draft_sync_to_public(
self, mock_signal):
"""
If a course run exists in "sync_to_public" mode (only draft version), and the course
does not exist in public version, the draft course run should be updated and the
related course should not be marked dirty (it will already be IRL...).
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX")
CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_public")
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 2042,
"catalog_visibility": "course_and_search",
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 6f85261b995a8ca78b5610cfe47fd6a0e321f26c671b606d12225bbea72fc8f0"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check that the draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_create_sync_to_public_draft_course(
self, mock_signal):
"""
If the submitted data is not related to an existing course run, a new course run should
be created. If the related course is draft, the synchronization is limited to the draft
course run and the course is not marked dirty (it will already be IRL...).
Demonstrate calculating the signature.
"""
course = CourseFactory(code="DemoX", should_publish=False)
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
data = {
"resource_link":
"http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/",
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
}
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
authorization = "SIG-HMAC-SHA256 {:s}".format(
hmac.new(
"shared secret".encode("utf-8"),
msg=json.dumps(data).encode("utf-8"),
digestmod=hashlib.sha256,
).hexdigest())
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=authorization,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check the new draft course run
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_existing_draft_sync_to_draft(
self, mock_signal):
"""
If a course run exists in "sync_to_draft" mode (only draft version),
the draft version should be udpated, the related course page should
be marked dirty and no public version should be created.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX", should_publish=True)
CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_draft")
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 986,
"catalog_visibility": "course_and_search",
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 3bed4a7b1595f49957bd949ed0192d5f1416d4f6a1c409fc8b03b1a1ebad0f39"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check that the draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DIRTY,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_create_sync_to_public_draft_course(
self, mock_signal):
"""
If the submitted data is not related to an existing course run, a new course run should
be created. If the related course is draft, the synchronization is limited to the draft
course run and the course is not marked dirty (it will already be IRL...).
Demonstrate calculating the signature.
"""
course = CourseFactory(code="DemoX", should_publish=False)
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
data = {
"resource_link":
"http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/",
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 46782,
"catalog_visibility": "course_and_search",
}
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
authorization = (
"SIG-HMAC-SHA256 "
"5bdfb326b35fccaef9961e03cf617c359c86ffbb6c64e0f7e074aa011e8af9d6")
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=authorization,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check the new draft course run
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_create_partial_not_required(
self, mock_signal):
"""
If the submitted data is not related to an existing course run and some optional fields
are missing, it should create the course run.
"""
course = CourseFactory(code="DemoX")
Title.objects.update(publisher_state=PUBLISHER_STATE_DEFAULT)
data = {
"resource_link":
"http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 45,
"catalog_visibility": "course_and_search",
}
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 723d3312759b6755bc8bbe05a9c2c719d2b4a3bdf381e2036a93119bf192aeda"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check the new draft course run
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
data.update({"start": None, "end": None, "enrollment_start": None})
self.assertEqual(draft_serializer.data, data)
# The page is not marked dirty because the course run is to be scheduled
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_create_sync_to_draft(self, mock_signal):
"""
If the submitted data is not related to an existing course run, a new course run should
be created. In "sync_to_draft" mode, the synchronization should be limited to the draft
course run, even if the related course is published.
"""
course = CourseFactory(code="DemoX", should_publish=True)
data = {
"resource_link":
"http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/",
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 47892,
"catalog_visibility": "course_and_search",
}
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 bb453816becb5df16949b915dd577a2cabf734e4429bfbd3bdb727bde39c58b7"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 1)
# Check the new draft course run
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DIRTY,
)
self.assertFalse(mock_signal.called)
def test_api_course_run_sync_existing_published_sync_to_public(
self, mock_signal):
"""
If a course run exists in "sync_to_public" mode (draft and public versions),
it should be updated, draft and public versions.
"""
link = "http://example.edx:8073/courses/course-v1:edX+DemoX+01/course/"
course = CourseFactory(code="DemoX")
CourseRunFactory(direct_course=course,
resource_link=link,
sync_mode="sync_to_public")
course.extended_object.publish("en")
course.refresh_from_db()
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.reset_mock()
data = {
"resource_link": link,
"start": "2020-12-09T09:31:59.417817Z",
"end": "2021-03-14T09:31:59.417895Z",
"enrollment_start": "2020-11-09T09:31:59.417936Z",
"enrollment_end": "2020-12-24T09:31:59.417972Z",
"languages": ["en", "fr"],
"enrollment_count": 15682,
"catalog_visibility": "course_and_search",
}
response = self.client.post(
"/api/v1.0/course-runs-sync",
data,
content_type="application/json",
HTTP_AUTHORIZATION=
("SIG-HMAC-SHA256 25de22f3674a207a2bd3923dcc5e302a21c9aac8eee7c835f084349da69d0472"
),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), {"success": True})
self.assertEqual(CourseRun.objects.count(), 2)
# Check that the existing draft course run was updated
draft_course_run = CourseRun.objects.get(direct_course=course)
draft_serializer = SyncCourseRunSerializer(instance=draft_course_run)
self.assertEqual(draft_serializer.data, data)
# Check that the existing public course run was updated
public_course_run = CourseRun.objects.get(
direct_course=course.public_extension)
public_serializer = SyncCourseRunSerializer(instance=public_course_run)
self.assertEqual(public_serializer.data, data)
self.assertEqual(
course.extended_object.title_set.first().publisher_state,
PUBLISHER_STATE_DEFAULT,
)
mock_signal.assert_called_once_with(sender=Page,
instance=course.extended_object,
language=None)
