Skip to content

C
course-discovery
Commit 4acf759a by Renzo Lucioni
Options

Publish course run status changes to the marketing site 

Generalizes program publication code so that it can be applied to any model, including course runs.

LEARNER-419
parent aabf4fcd
Showing with 966 additions and 529 deletions
course_discovery/apps/course_metadata/admin.py
......@@ -4,10 +4,17 @@ from django.http import HttpResponseRedirect
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _
from course_discovery.apps.course_metadata.exceptions import (
MarketingSiteAPIClientException, MarketingSitePublisherException
)
from course_discovery.apps.course_metadata.forms import CourseAdminForm, ProgramAdminForm
from course_discovery.apps.course_metadata.models import * # pylint: disable=wildcard-import
from course_discovery.apps.course_metadata.publishers import ProgramPublisherException
from course_discovery.apps.course_metadata.utils import MarketingSiteAPIClientException
PUBLICATION_FAILURE_MSG_TPL = _(
'An error occurred while publishing the {model} to the marketing site. '
'Please try again. If the error persists, please contact the Engineering Team.'
)
class ProgramEligibilityFilter(admin.SimpleListFilter):
......@@ -101,6 +108,24 @@ class CourseRunAdmin(admin.ModelAdmin):
ordering = ('key',)
readonly_fields = ('uuid',)
search_fields = ('uuid', 'key', 'title_override', 'course__title', 'slug',)
save_error = False
def response_change(self, request, obj):
if self.save_error:
return self.response_post_save_change(request, obj)
return super().response_change(request, obj)
def save_model(self, request, obj, form, change):
try:
super().save_model(request, obj, form, change)
except (MarketingSitePublisherException, MarketingSiteAPIClientException):
self.save_error = True
logger.exception('An error occurred while publishing course run [%s] to the marketing site.', obj.key)
msg = PUBLICATION_FAILURE_MSG_TPL.format(model='course run') # pylint: disable=no-member
messages.add_message(request, messages.ERROR, msg)
@admin.register(Program)
......@@ -158,15 +183,14 @@ class ProgramAdmin(admin.ModelAdmin):
def save_model(self, request, obj, form, change):
try:
super().save_model(request, obj, form, change)
self.save_error = False
except (ProgramPublisherException, MarketingSiteAPIClientException):
# TODO Redirect the user back to the form so that he/she can try again.
logger.exception('An error occurred while publishing the program [%s] to the marketing site.', obj.uuid)
msg = _('An error occurred while publishing the program to the marketing site. Please try again. '
'If the error persists, please contact the Engineering Team.')
messages.add_message(request, messages.ERROR, msg)
except (MarketingSitePublisherException, MarketingSiteAPIClientException):
self.save_error = True
logger.exception('An error occurred while publishing program [%s] to the marketing site.', obj.uuid)
msg = PUBLICATION_FAILURE_MSG_TPL.format(model='program') # pylint: disable=no-member
messages.add_message(request, messages.ERROR, msg)
class Media:
js = ('bower_components/jquery-ui/ui/minified/jquery-ui.min.js',
'js/sortable_select.js')
......
course_discovery/apps/course_metadata/exceptions.py
class MarketingSiteAPIClientException(Exception):
""" The exception thrown from MarketingSiteAPIClient """
pass
class ProgramPublisherException(Exception):
""" The exception thrown during the program publishing process to marketing site """
class MarketingSitePublisherException(Exception):
pass
def __init__(self, message):
super(ProgramPublisherException, self).__init__(message)
suffix = 'The program data has not been saved. Please check your marketing site configuration'
self.message = '{exception_msg} {suffix}'.format(exception_msg=message, suffix=suffix)
class AliasCreateError(MarketingSitePublisherException):
pass
class AliasDeleteError(MarketingSitePublisherException):
pass
class FormRetrievalError(MarketingSitePublisherException):
pass
class NodeCreateError(MarketingSitePublisherException):
pass
class NodeDeleteError(MarketingSitePublisherException):
pass
class NodeEditError(MarketingSitePublisherException):
pass
class NodeLookupError(MarketingSitePublisherException):
pass
class PersonToMarketingException(Exception):
......
course_discovery/apps/course_metadata/forms.py
......@@ -94,8 +94,8 @@ class CourseRunSelectionForm(forms.ModelForm):
)
query_set = [course.pk for course in instance.courses.all()]
self.fields["excluded_course_runs"].widget = forms.widgets.CheckboxSelectMultiple()
self.fields["excluded_course_runs"].help_text = ""
self.fields['excluded_course_runs'].widget = forms.widgets.CheckboxSelectMultiple()
self.fields['excluded_course_runs'].help_text = ''
self.fields['excluded_course_runs'].queryset = CourseRun.objects.filter(
course__id__in=query_set
)
......
course_discovery/apps/course_metadata/migrations/0052_create_course_run_publication_switch.py 0 → 100644
from django.db import migrations
SWITCH = 'publish_course_runs_to_marketing_site'
def create_switch(apps, schema_editor):
"""Create the publish_course_runs_to_marketing_site switch."""
Switch = apps.get_model('waffle', 'Switch')
Switch.objects.get_or_create(name=SWITCH, defaults={'active': False})
def delete_switch(apps, schema_editor):
"""Delete the publish_course_runs_to_marketing_site switch."""
Switch = apps.get_model('waffle', 'Switch')
Switch.objects.filter(name=SWITCH).delete()
class Migration(migrations.Migration):
dependencies = [
('course_metadata', '0051_program_one_click_purchase_enabled'),
('waffle', '0001_initial'),
]
operations = [
migrations.RunPython(create_switch, reverse_code=delete_switch),
]
course_discovery/apps/course_metadata/models.py
......@@ -23,7 +23,10 @@ from taggit_autosuggest.managers import TaggableManager
from course_discovery.apps.core.models import Currency, Partner
from course_discovery.apps.course_metadata.choices import CourseRunPacing, CourseRunStatus, ProgramStatus, ReportingType
from course_discovery.apps.course_metadata.publishers import MarketingSitePublisher
from course_discovery.apps.course_metadata.publishers import (
CourseRunMarketingSitePublisher,
ProgramMarketingSitePublisher
)
from course_discovery.apps.course_metadata.query import CourseQuerySet, CourseRunQuerySet, ProgramQuerySet
from course_discovery.apps.course_metadata.utils import UploadToFieldNamePath, clean_query, custom_render_variations
from course_discovery.apps.ietf_language_tags.models import LanguageTag
......@@ -337,7 +340,6 @@ class Course(TimeStampedModel):
class CourseRun(TimeStampedModel):
""" CourseRun model. """
uuid = models.UUIDField(default=uuid4, editable=False, verbose_name=_('UUID'))
course = models.ForeignKey(Course, related_name='course_runs')
key = models.CharField(max_length=255, unique=True)
......@@ -595,6 +597,22 @@ class CourseRun(TimeStampedModel):
def __str__(self):
return '{key}: {title}'.format(key=self.key, title=self.title)
def save(self, *args, **kwargs):
is_publishable = (
self.course.partner.has_marketing_site and
waffle.switch_is_active('publish_course_runs_to_marketing_site')
)
if is_publishable:
publisher = CourseRunMarketingSitePublisher(self.course.partner)
previous_obj = CourseRun.objects.get(id=self.id) if self.id else None
with transaction.atomic():
super(CourseRun, self).save(*args, **kwargs)
publisher.publish_obj(self, previous_obj=previous_obj)
else:
super(CourseRun, self).save(*args, **kwargs)
class SeatType(TimeStampedModel):
name = models.CharField(max_length=64, unique=True)
......@@ -973,19 +991,18 @@ class Program(TimeStampedModel):
return self.status == ProgramStatus.Active
def save(self, *args, **kwargs):
if waffle.switch_is_active('publish_program_to_marketing_site') and self.partner.has_marketing_site:
# Before save, get from database the existing data if exists
existing_program = None
if self.id:
existing_program = Program.objects.get(id=self.id)
# Pass existing data to the publisher so it can decide whether we should publish
publisher = MarketingSitePublisher(existing_program)
is_publishable = (
self.partner.has_marketing_site and
waffle.switch_is_active('publish_program_to_marketing_site')
)
if is_publishable:
publisher = ProgramMarketingSitePublisher(self.partner)
previous_obj = Program.objects.get(id=self.id) if self.id else None
with transaction.atomic():
super(Program, self).save(*args, **kwargs)
# Once save complete, we need to update the marketing site
# So the marketing page for this program is automatically updated
publisher.publish_program(self)
publisher.publish_obj(self, previous_obj=previous_obj)
else:
super(Program, self).save(*args, **kwargs)
......
course_discovery/apps/course_metadata/publishers.py
import json
from urllib.parse import urljoin
from bs4 import BeautifulSoup
from django.utils.functional import cached_property
from course_discovery.apps.course_metadata.exceptions import ProgramPublisherException
from course_discovery.apps.course_metadata.choices import CourseRunStatus
from course_discovery.apps.course_metadata.exceptions import (
AliasCreateError,
AliasDeleteError,
FormRetrievalError,
NodeCreateError,
NodeDeleteError,
NodeEditError,
NodeLookupError
)
from course_discovery.apps.course_metadata.utils import MarketingSiteAPIClient
class MarketingSitePublisher(object):
class BaseMarketingSitePublisher:
"""
This is the publisher that would publish the object data to marketing site
Utility for publishing data to a Drupal marketing site.
Arguments:
partner (apps.core.models.Partner): Partner instance containing information
about the marketing site to which to publish.
"""
program_before = None
unique_field = None
node_lookup_field = None
def __init__(self, program_before=None):
if program_before:
self.program_before = program_before
def __init__(self, partner):
self.partner = partner
def _get_api_client(self, program):
if not program.partner.has_marketing_site:
return
self.client = MarketingSiteAPIClient(
self.partner.marketing_site_api_username,
self.partner.marketing_site_api_password,
self.partner.marketing_site_url_root
)
if not (program.partner.marketing_site_api_username and program.partner.marketing_site_api_password):
msg = 'Marketing Site API credentials are not properly configured for Partner [{partner}]!'.format(
partner=program.partner.short_code)
raise ProgramPublisherException(msg)
self.node_api_base = urljoin(self.client.api_url, '/node.json')
if program.type.name not in ['MicroMasters', 'Professional Certificate']:
# We do not publish programs that are not MicroMasters or Professional Certificate to the Marketing Site
return
def publish_obj(self, obj, previous_obj=None):
"""
Update or create a Drupal node corresponding to the given model instance.
fields_that_trigger_publish = ['title', 'status', 'type', 'marketing_slug']
if self.program_before and \
all(getattr(self.program_before, key) == getattr(program, key) for key in fields_that_trigger_publish):
# We don't need to publish to marketing site because
# nothing we care about has changed. This would save at least 4 network calls
return
Arguments:
obj (django.db.models.Model): Model instance to be published.
return MarketingSiteAPIClient(
program.partner.marketing_site_api_username,
program.partner.marketing_site_api_password,
program.partner.marketing_site_url_root
)
Keyword Arguments:
previous_obj (CourseRun): Model instance representing the previous
state of the model being changed. Inspected to determine if publication
is necessary. May not exist if the model instance is being saved
for the first time.
"""
raise NotImplementedError
def delete_obj(self, obj):
"""
Delete a Drupal node corresponding to the given model instance.
Arguments:
obj (django.db.models.Model): Model instance to be deleted.
"""
node_id = self.node_id(obj)
def _get_node_data(self, program, user_id):
self.delete_node(node_id)
def serialize_obj(self, obj):
"""
Serialize a model instance to a representation that can be written to Drupal.
Arguments:
obj (django.db.models.Model): Model instance to be published.
Returns:
dict: Data to PUT to the Drupal API.
"""
return {
'type': str(program.type).lower().replace(' ', '_'),
'title': program.title,
'field_uuid': str(program.uuid),
'uuid': str(program.uuid),
'author': {
'id': user_id,
},
'status': 1 if program.is_active else 0
self.node_lookup_field: str(getattr(obj, self.unique_field)),
'author': {'id': self.client.user_id},
}
def _get_node_id(self, api_client, uuid):
node_url = '{root}/node.json?field_uuid={uuid}'.format(root=api_client.api_url, uuid=uuid)
response = api_client.api_session.get(node_url)
def node_id(self, obj):
"""
Find the ID of the node we want to publish to, if it exists.
Arguments:
obj (django.db.models.Model): Model instance to be published.
Returns:
str: The node ID.
Raises:
NodeLookupError: If node lookup fails.
"""
params = {
self.node_lookup_field: getattr(obj, self.unique_field),
}
response = self.client.api_session.get(self.node_api_base, params=params)
if response.status_code == 200:
list_item = response.json().get('list')
if list_item:
return list_item[0]['nid']
return response.json()['list'][0]['nid']
else:
raise NodeLookupError
def _edit_node(self, api_client, node_id, node_data):
# Drupal does not allow us to update the UUID field on node update
node_data.pop('uuid', None)
node_url = '{root}/node.json/{node_id}'.format(root=api_client.api_url, node_id=node_id)
response = api_client.api_session.put(node_url, data=json.dumps(node_data))
if response.status_code != 200:
raise ProgramPublisherException("Marketing site page edit failed!")
def create_node(self, node_data):
"""
Create a Drupal node.
Arguments:
node_data (dict): Data to POST to Drupal for node creation.
Returns:
str: The ID of the created node.
Raises:
NodeCreateError: If the POST to Drupal fails.
"""
node_data = json.dumps(node_data)
response = self.client.api_session.post(self.node_api_base, data=node_data)
def _create_node(self, api_client, node_data):
node_url = '{root}/node.json'.format(root=api_client.api_url)
response = api_client.api_session.post(node_url, data=json.dumps(node_data))
if response.status_code == 201:
response_json = response.json()
return response_json['id']
return response.json()['id']
else:
raise ProgramPublisherException("Marketing site page creation failed!")
raise NodeCreateError
def edit_node(self, node_id, node_data):
"""
Edit a Drupal node.
def _delete_node(self, api_client, node_id):
node_url = '{root}/node.json/{node_id}'.format(root=api_client.api_url, node_id=node_id)
api_client.api_session.delete(node_url)
Arguments:
node_id (str): ID of the node to edit.
node_data (dict): Fields to overwrite on the node.
Raises:
NodeEditError: If the PUT to Drupal fails.
"""
node_url = '{base}/{node_id}'.format(base=self.node_api_base, node_id=node_id)
node_data = json.dumps(node_data)
response = self.client.api_session.put(node_url, data=node_data)
def _get_form_build_id_and_form_token(self, api_client, url):
form_attributes = {}
response = api_client.api_session.get(url)
if response.status_code != 200:
raise ProgramPublisherException('Marketing site alias form retrieval failed!')
form = BeautifulSoup(response.text, 'html.parser')
for field in ('form_build_id', 'form_token'):
form_attributes[field] = form.find('input', {'name': field}).get('value')
return form_attributes
def _get_delete_alias_url(self, api_client, url):
response = api_client.api_session.get(url)
raise NodeEditError
def delete_node(self, node_id):
"""
Delete a Drupal node.
Arguments:
node_id (str): ID of the node to delete.
Raises:
NodeDeleteError: If the DELETE to Drupal fails.
"""
node_url = '{base}/{node_id}'.format(base=self.node_api_base, node_id=node_id)
response = self.client.api_session.delete(node_url)
if response.status_code != 200:
raise ProgramPublisherException('Marketing site alias form retrieval failed!')
form = BeautifulSoup(response.text, 'html.parser')
delete_element = form.select('.delete.last a')
return delete_element[0].get('href') if delete_element else None
raise NodeDeleteError
def _get_headers(self):
headers = {
'content-type': 'application/x-www-form-urlencoded'
class CourseRunMarketingSitePublisher(BaseMarketingSitePublisher):
"""
Utility for publishing course run data to a Drupal marketing site.
"""
unique_field = 'key'
node_lookup_field = 'field_course_id'
def publish_obj(self, obj, previous_obj=None):
"""
Publish a CourseRun to the marketing site.
Publication only occurs if the CourseRun's status has changed.
Arguments:
obj (CourseRun): CourseRun instance to be published.
Keyword Arguments:
previous_obj (CourseRun): Previous state of the course run. Inspected to
determine if publication is necessary. May not exist if the course run
is being saved for the first time.
"""
if previous_obj and obj.status != previous_obj.status:
node_id = self.node_id(obj)
node_data = self.serialize_obj(obj)
self.edit_node(node_id, node_data)
def serialize_obj(self, obj):
"""
Serialize the CourseRun instance to be published.
Arguments:
obj (CourseRun): CourseRun instance to be published.
Returns:
dict: Data to PUT to the Drupal API.
"""
data = super().serialize_obj(obj)
return {
**data,
'status': 1 if obj.status == CourseRunStatus.Published else 0,
}
return headers
def _make_alias(self, program):
alias = '{program_type_slug}/{slug}'.format(program_type_slug=program.type.slug, slug=program.marketing_slug)
return alias
def _add_alias(self, api_client, node_id, alias, before_slug):
base_aliases_url = '{root}/admin/config/search/path'.format(root=api_client.api_url)
add_aliases_url = '{url}/add'.format(url=base_aliases_url)
node_url = 'node/{node_id}'.format(node_id=node_id)
class ProgramMarketingSitePublisher(BaseMarketingSitePublisher):
"""
Utility for publishing program data to a Drupal marketing site.
"""
unique_field = 'uuid'
node_lookup_field = 'field_uuid'
def __init__(self, partner):
super().__init__(partner)
self.alias_api_base = urljoin(self.client.api_url, '/admin/config/search/path')
self.alias_add_url = '{}/add'.format(self.alias_api_base)
def publish_obj(self, obj, previous_obj=None):
"""
Publish a Program to the marketing site.
Arguments:
obj (Program): Program instance to be published.
Keyword Arguments:
previous_obj (Program): Previous state of the program. Inspected to
determine if publication is necessary. May not exist if the program
is being saved for the first time.
"""
if obj.type.name in {'MicroMasters', 'Professional Certificate'}:
node_data = self.serialize_obj(obj)
node_id = None
if not previous_obj:
node_id = self.create_node(node_data)
else:
trigger_fields = (
'marketing_slug',
'status',
'title',
'type',
)
if any(getattr(obj, field) != getattr(previous_obj, field) for field in trigger_fields):
node_id = self.node_id(obj)
# Drupal does not allow modification of the UUID field.
node_data.pop('uuid', None)
self.edit_node(node_id, node_data)
if node_id:
self.update_node_alias(obj, node_id, previous_obj)
def serialize_obj(self, obj):
"""
Serialize the Program instance to be published.
Arguments:
obj (Program): Program instance to be published.
Returns:
dict: Data to PUT to the Drupal API.
"""
data = super().serialize_obj(obj)
return {
**data,
'status': 1 if obj.is_active else 0,
'title': obj.title,
'type': str(obj.type).lower().replace(' ', '_'),
'uuid': str(obj.uuid),
}
def update_node_alias(self, obj, node_id, previous_obj):
"""
Update alias of the Drupal node corresponding to the given object.
Arguments:
obj (Program): Program instance to be published.
node_id (str): The ID of the node corresponding to the object.
previous_obj (Program): Previous state of the program. May be None.
Raises:
AliasCreateError: If there's a problem creating a new alias.
AliasDeleteError: If there's a problem deleting an old alias.
"""
new_alias = self.alias(obj)
previous_alias = self.alias(previous_obj) if previous_obj else None
if new_alias != previous_alias:
alias_add_url = '{}/add'.format(self.alias_api_base)
headers = {
'content-type': 'application/x-www-form-urlencoded'
}
data = {
'source': node_url,
'alias': alias,
**self.alias_form_inputs,
'alias': new_alias,
'form_id': 'path_admin_form',
'op': 'Save'
'op': 'Save',
'source': 'node/{}'.format(node_id),
}
form_attributes = self._get_form_build_id_and_form_token(api_client, add_aliases_url)
data.update(form_attributes)
headers = self._get_headers()
response = api_client.api_session.post(add_aliases_url, headers=headers, data=data)
response = self.client.api_session.post(alias_add_url, headers=headers, data=data)
if response.status_code != 200:
raise ProgramPublisherException('Marketing site alias creation failed!')
# Delete old alias after saving new one
if before_slug:
list_aliases_url = '{url}/list/{slug}'.format(url=base_aliases_url, slug=before_slug)
delete_alias_url = self._get_delete_alias_url(api_client, list_aliases_url)
if delete_alias_url:
delete_alias_url = '{root}{url}'.format(root=api_client.api_url, url=delete_alias_url)
raise AliasCreateError
# Delete old alias after saving the new one.
if previous_obj:
alias_list_url = '{base}/list/{slug}'.format(
base=self.alias_api_base,
slug=previous_obj.marketing_slug
)
alias_delete_path = self.alias_delete_path(alias_list_url)
if alias_delete_path:
alias_delete_url = '{base}/{path}'.format(
base=self.client.api_url,
path=alias_delete_path.strip('/')
)
data = {
"confirm": 1,
"form_id": "path_admin_delete_confirm",
"op": "Confirm"
**self.alias_form_inputs,
'confirm': 1,
'form_id': 'path_admin_delete_confirm',
'op': 'Confirm',
}
form_attributes = self._get_form_build_id_and_form_token(api_client, delete_alias_url)
data.update(form_attributes)
response = api_client.api_session.post(delete_alias_url, headers=headers, data=data)
response = self.client.api_session.post(alias_delete_url, headers=headers, data=data)
if response.status_code != 200:
raise ProgramPublisherException('Marketing site alias deletion failed!')
raise AliasDeleteError
def publish_program(self, program):
api_client = self._get_api_client(program)
if api_client:
node_data = self._get_node_data(program, api_client.user_id)
node_id = self._get_node_id(api_client, program.uuid)
if node_id:
# We would like to edit the existing node
self._edit_node(api_client, node_id, node_data)
else:
# We should create a new node
node_id = self._create_node(api_client, node_data)
before_alias = self._make_alias(self.program_before) if self.program_before else None
new_alias = self._make_alias(program)
before_slug = self.program_before.marketing_slug if self.program_before else None
if not self.program_before or (before_alias != new_alias):
self._add_alias(api_client, node_id, new_alias, before_slug)
def delete_program(self, program):
api_client = self._get_api_client(program)
if api_client:
node_id = self._get_node_id(api_client, program.uuid)
if node_id:
self._delete_node(api_client, node_id)
def alias(self, obj):
return '{type}/{slug}'.format(type=obj.type.slug, slug=obj.marketing_slug)
@cached_property
def alias_form_inputs(self):
"""
Scrape input values from the form used to modify Drupal aliases.
Raises:
FormRetrievalError: If there's a problem getting the form from Drupal.
"""
response = self.client.api_session.get(self.alias_add_url)
if response.status_code != 200:
raise FormRetrievalError
html = BeautifulSoup(response.text, 'html.parser')
return {
field: html.find('input', {'name': field}).get('value')
for field in ('form_build_id', 'form_token')
}
def alias_delete_path(self, url):
"""
Scrape the path to which we need to POST to delete an alias from the form
used to modify aliases.
Raises:
FormRetrievalError: If there's a problem getting the form from Drupal.
"""
response = self.client.api_session.get(url)
if response.status_code != 200:
raise FormRetrievalError
html = BeautifulSoup(response.text, 'html.parser')
delete_element = html.select('.delete.last a')
return delete_element[0].get('href') if delete_element else None
course_discovery/apps/course_metadata/signals.py
......@@ -3,12 +3,16 @@ from django.db.models.signals import pre_delete
from django.dispatch import receiver
from course_discovery.apps.course_metadata.models import Program
from course_discovery.apps.course_metadata.publishers import MarketingSitePublisher
from course_discovery.apps.course_metadata.publishers import ProgramMarketingSitePublisher
@receiver(pre_delete, sender=Program)
def delete_program(sender, instance, **kwargs): # pylint: disable=unused-argument
if waffle.switch_is_active('publish_program_to_marketing_site') and \
instance.partner.has_marketing_site:
publisher = MarketingSitePublisher()
publisher.delete_program(instance)
is_publishable = (
instance.partner.has_marketing_site and
waffle.switch_is_active('publish_program_to_marketing_site')
)
if is_publishable:
publisher = ProgramMarketingSitePublisher(instance.partner)
publisher.delete_obj(instance)
course_discovery/apps/course_metadata/tests/mixins.py
import json
import random
import urllib
import responses
......@@ -77,49 +78,46 @@ class MarketingSiteAPIClientTestMixin(TestCase):
class MarketingSitePublisherTestMixin(MarketingSiteAPIClientTestMixin):
"""
The mixing to help mock the responses for marketing site publisher
Mixin for mocking Drupal responses when testing marketing site publishers.
"""
def setUp(self):
super(MarketingSitePublisherTestMixin, self).setUp()
self.node_id = FuzzyText().fuzz()
self.node_id = str(random.randint(1, 1000))
def mock_api_client(self, status):
def mock_api_client(self, status=200):
self.mock_login_response(status)
self.mock_csrf_token_response(status)
self.mock_user_id_response(status)
def mock_node_retrieval(self, program_uuid, exists=True):
data = {}
status = 200
def mock_node_retrieval(self, node_lookup_field, node_lookup_value, exists=True, status=200):
url = '{root}/node.json?{node_lookup_field}={node_lookup_value}'.format(
root=self.api_root,
node_lookup_field=node_lookup_field,
node_lookup_value=node_lookup_value,
)
data = {
'list': []
'list': [{'nid': self.node_id}] if exists else []
}
if exists:
data['list'] = [{
'nid': self.node_id
}]
responses.add(
responses.GET,
'{root}/node.json?field_uuid={uuid}'.format(root=self.api_root, uuid=str(program_uuid)),
url,
body=json.dumps(data),
content_type='application/json',
status=status,
match_querystring=True
)
def mock_add_alias(self, status=200):
def mock_add_alias(self, alias=None, status=200):
node_url = 'node/{node_id}'.format(node_id=self.node_id)
alias = '{program_type}/{slug}'.format(
program_type=self.program.type.name.lower(),
slug=self.program.marketing_slug
)
data = {
'source': node_url,
'alias': alias,
'form_id': 'path_admin_form',
'op': 'Save'
}
responses.add(
responses.POST,
'{root}/admin/config/search/path/add'.format(root=self.api_root),
......@@ -129,13 +127,14 @@ class MarketingSitePublisherTestMixin(MarketingSiteAPIClientTestMixin):
def mock_delete_alias(self, status=200):
data = {
"confirm": 1,
"form_id": "path_admin_delete_confirm",
"op": "Confirm"
'confirm': 1,
'form_id': 'path_admin_delete_confirm',
'op': 'Confirm'
}
responses.add(
responses.POST,
'{root}/foo'.format(root=self.api_root),
'{root}/admin/config/search/path/delete/foo'.format(root=self.api_root),
body=urllib.parse.urlencode(data),
status=status
)
......@@ -154,12 +153,15 @@ class MarketingSitePublisherTestMixin(MarketingSiteAPIClientTestMixin):
responses.GET,
'{root}/admin/config/search/path/list/{alias}'.format(root=self.api_root, alias=alias),
status=status,
body='<li class="delete last"><a href="/admin/config/search/path/delete/bar"></a></li>'
body='<li class="delete last"><a href="/admin/config/search/path/delete/foo"></a></li>'
)
def mock_node_create(self, response_data, status):
responses.add(
responses.POST,
'{root}/admin/config/search/path/delete/bar'.format(root=self.api_root),
'{root}/node.json'.format(root=self.api_root),
body=json.dumps(response_data),
content_type='application/json',
status=status
)
......@@ -172,15 +174,6 @@ class MarketingSitePublisherTestMixin(MarketingSiteAPIClientTestMixin):
status=status
)
def mock_node_create(self, response_data, status):
responses.add(
responses.POST,
'{root}/node.json'.format(root=self.api_root),
body=json.dumps(response_data),
content_type='application/json',
status=status
)
def mock_node_delete(self, status):
responses.add(
responses.DELETE,
......
course_discovery/apps/course_metadata/tests/test_models.py
......@@ -4,13 +4,11 @@ from decimal import Decimal
import ddt
import mock
import responses
from dateutil.parser import parse
from django.conf import settings
from django.db import IntegrityError
from django.db.models.functions import Lower
from django.test import TestCase
from factory.fuzzy import FuzzyText
from freezegun import freeze_time
from course_discovery.apps.core.models import Currency
......@@ -20,12 +18,13 @@ from course_discovery.apps.core.utils import SearchQuerySetWrapper
from course_discovery.apps.course_metadata.choices import ProgramStatus
from course_discovery.apps.course_metadata.models import (
FAQ, AbstractMediaModel, AbstractNamedModel, AbstractValueModel, CorporateEndorsement, Course, CourseRun,
Endorsement, ProgramType, Seat, SeatType
Endorsement, Seat, SeatType
)
from course_discovery.apps.course_metadata.publishers import (
CourseRunMarketingSitePublisher, ProgramMarketingSitePublisher
)
from course_discovery.apps.course_metadata.publishers import MarketingSitePublisher
from course_discovery.apps.course_metadata.tests import factories, toggle_switch
from course_discovery.apps.course_metadata.tests.factories import CourseRunFactory, ImageFactory
from course_discovery.apps.course_metadata.tests.mixins import MarketingSitePublisherTestMixin
from course_discovery.apps.ietf_language_tags.models import LanguageTag
......@@ -257,7 +256,7 @@ class CourseRunTests(TestCase):
@ddt.unpack
def test_get_paid_seat_enrollment_end(self, seat_config, course_end, course_enrollment_end, expected_result):
"""
Verify that paid_seat_enrollment_end returns the latest possible date for which an unerolled user may
Verify that paid_seat_enrollment_end returns the latest possible date for which an unenrolled user may
enroll and purchase an upgrade for the CourseRun or None if date unknown or paid Seats are not available.
"""
end = parse(course_end) if course_end else None
......@@ -270,6 +269,43 @@ class CourseRunTests(TestCase):
expected_result = parse(expected_result) if expected_result else None
self.assertEqual(course_run.get_paid_seat_enrollment_end(), expected_result)
def test_publication_disabled(self):
"""
Verify that the publisher is not initialized when publication is disabled.
"""
toggle_switch('publish_course_runs_to_marketing_site', active=False)
with mock.patch.object(CourseRunMarketingSitePublisher, '__init__') as mock_init:
self.course_run.save()
self.course_run.delete()
assert mock_init.call_count == 0
toggle_switch('publish_course_runs_to_marketing_site')
self.course_run.course.partner.marketing_site_url_root = ''
self.course_run.course.partner.save()
with mock.patch.object(CourseRunMarketingSitePublisher, '__init__') as mock_init:
self.course_run.save()
self.course_run.delete()
assert mock_init.call_count == 0
def test_publication_enabled(self):
"""
Verify that the publisher is called when publication is enabled.
"""
toggle_switch('publish_course_runs_to_marketing_site')
with mock.patch.object(CourseRunMarketingSitePublisher, 'publish_obj', return_value=None) as mock_publish_obj:
self.course_run.save()
assert mock_publish_obj.called
with mock.patch.object(CourseRunMarketingSitePublisher, 'delete_obj', return_value=None) as mock_delete_obj:
self.course_run.delete()
# We don't want to delete course run nodes when CourseRuns are deleted.
assert not mock_delete_obj.called
class OrganizationTests(TestCase):
""" Tests for the `Organization` model. """
......@@ -390,7 +426,7 @@ class AbstractValueModelTests(TestCase):
@ddt.ddt
class ProgramTests(MarketingSitePublisherTestMixin):
class ProgramTests(TestCase):
"""Tests of the Program model."""
def setUp(self):
......@@ -737,77 +773,41 @@ class ProgramTests(MarketingSitePublisherTestMixin):
self.program.status = status
self.assertEqual(self.program.is_active, status == ProgramStatus.Active)
@responses.activate
def test_save_without_publish(self):
self.program.title = FuzzyText().fuzz()
self.program.save()
self.assert_responses_call_count(0)
def test_publication_disabled(self):
"""
Verify that the publisher is not initialized when publication is disabled.
"""
toggle_switch('publish_program_to_marketing_site', active=False)
@responses.activate
def test_delete_without_publish(self):
with mock.patch.object(ProgramMarketingSitePublisher, '__init__') as mock_init:
self.program.save()
self.program.delete()
self.assert_responses_call_count(0)
@responses.activate
def test_save_and_publish_success(self):
self.program.partner.marketing_site_url_root = self.api_root
self.program.partner.marketing_site_api_username = self.username
self.program.partner.marketing_site_api_password = self.password
self.program.type = ProgramType.objects.get(name='MicroMasters')
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
toggle_switch('publish_program_to_marketing_site', True)
self.program.title = FuzzyText().fuzz()
self.mock_add_alias()
self.mock_delete_alias()
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_delete_alias_url', return_value='/foo'):
assert mock_init.call_count == 0
toggle_switch('publish_program_to_marketing_site')
self.program.partner.marketing_site_url_root = ''
self.program.partner.save()
with mock.patch.object(ProgramMarketingSitePublisher, '__init__') as mock_init:
self.program.save()
self.assert_responses_call_count(8)
self.program.delete()
@responses.activate
def test_xseries_program_save(self):
assert mock_init.call_count == 0
def test_publication_enabled(self):
"""
Make sure if the Program instance is of type XSeries, we do not publish to Marketing Site
Verify that the publisher is called when publication is enabled.
"""
self.program.partner.marketing_site_url_root = self.api_root
self.program.partner.marketing_site_api_username = self.username
self.program.partner.marketing_site_api_password = self.password
self.program.type = ProgramType.objects.get(name='XSeries')
toggle_switch('publish_program_to_marketing_site', True)
self.program.title = FuzzyText().fuzz()
self.program.save()
self.assert_responses_call_count(0)
toggle_switch('publish_program_to_marketing_site')
@responses.activate
def test_save_and_no_marketing_site(self):
self.program.partner.marketing_site_url_root = None
toggle_switch('publish_program_to_marketing_site', True)
self.program.title = FuzzyText().fuzz()
with mock.patch.object(ProgramMarketingSitePublisher, 'publish_obj', return_value=None) as mock_publish_obj:
self.program.save()
self.assert_responses_call_count(0)
@responses.activate
def test_delete_and_publish_success(self):
self.program.partner.marketing_site_url_root = self.api_root
self.program.partner.marketing_site_api_username = self.username
self.program.partner.marketing_site_api_password = self.password
self.program.type = ProgramType.objects.get(name='MicroMasters')
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_delete(204)
toggle_switch('publish_program_to_marketing_site', True)
self.program.delete()
self.assert_responses_call_count(5)
assert mock_publish_obj.called
@responses.activate
def test_delete_and_no_marketing_site(self):
self.program.partner.marketing_site_url_root = None
toggle_switch('publish_program_to_marketing_site', True)
with mock.patch.object(ProgramMarketingSitePublisher, 'delete_obj', return_value=None) as mock_delete_obj:
self.program.delete()
self.assert_responses_call_count(0)
assert mock_delete_obj.called
class PersonSocialNetworkTests(TestCase):
......
course_discovery/apps/course_metadata/tests/test_people.py
......@@ -3,8 +3,8 @@ import responses
from course_discovery.apps.core.tests.factories import PartnerFactory
from course_discovery.apps.course_metadata.exceptions import PersonToMarketingException
from course_discovery.apps.course_metadata.people import MarketingSitePeople
from course_discovery.apps.course_metadata.publishers import MarketingSiteAPIClient
from course_discovery.apps.course_metadata.tests.mixins import MarketingSitePublisherTestMixin
from course_discovery.apps.course_metadata.utils import MarketingSiteAPIClient
class MarketingSitePublisherTests(MarketingSitePublisherTestMixin):
......@@ -71,6 +71,6 @@ class MarketingSitePublisherTests(MarketingSitePublisherTestMixin):
@responses.activate
def test_delete_program(self):
self.mock_api_client(200)
self.mock_node_delete(204)
self.mock_node_delete(200)
people = MarketingSitePeople()
people.delete_person(self.partner, self.node_id)
course_discovery/apps/course_metadata/tests/test_publishers.py
import json
import mock
import pytest
import responses
from course_discovery.apps.course_metadata.choices import ProgramStatus
from course_discovery.apps.course_metadata.models import ProgramType
from course_discovery.apps.core.tests.factories import PartnerFactory
from course_discovery.apps.course_metadata.choices import CourseRunStatus, ProgramStatus
from course_discovery.apps.course_metadata.exceptions import (
AliasCreateError,
AliasDeleteError,
NodeCreateError,
NodeDeleteError,
NodeEditError,
NodeLookupError
)
from course_discovery.apps.course_metadata.publishers import (
MarketingSiteAPIClient, MarketingSitePublisher, ProgramPublisherException
BaseMarketingSitePublisher, CourseRunMarketingSitePublisher, ProgramMarketingSitePublisher
)
from course_discovery.apps.course_metadata.tests.factories import ProgramFactory
from course_discovery.apps.course_metadata.tests.factories import CourseRunFactory, ProgramFactory
from course_discovery.apps.course_metadata.tests.mixins import MarketingSitePublisherTestMixin
class MarketingSitePublisherTests(MarketingSitePublisherTestMixin):
class DummyObject:
dummy = 2
class BaseMarketingSitePublisherTests(MarketingSitePublisherTestMixin):
"""
Unit test cases for the MarketingSitePublisher
Tests covering shared publishing logic.
"""
def setUp(self):
super(MarketingSitePublisherTests, self).setUp()
self.program = ProgramFactory()
self.program.partner.marketing_site_url_root = self.api_root
self.program.partner.marketing_site_api_username = self.username
self.program.partner.marketing_site_api_password = self.password
self.program.type = ProgramType.objects.get(name='MicroMasters')
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
self.program.save() # pylint: disable=no-member
self.api_client = MarketingSiteAPIClient(
self.username,
self.password,
self.api_root
)
self.expected_node = {
'uuid': '945bb2c7-0a57-4a3f-972a-8c7f94aa0661',
'resource': 'node',
'uri': 'https://stage.edx.org/node/28426',
'id': '28426'
}
super().setUp()
self.partner = PartnerFactory()
self.publisher = BaseMarketingSitePublisher(self.partner)
self.publisher.unique_field = 'dummy'
self.publisher.node_lookup_field = 'field_dummy'
self.api_root = self.publisher.client.api_url
self.username = self.publisher.client.username
def test_get_node_data(self):
publisher = MarketingSitePublisher()
publish_data = publisher._get_node_data(self.program, self.user_id) # pylint: disable=protected-access
self.obj = DummyObject()
def test_publish_obj(self):
"""
Verify that the base publisher doesn't implement this method.
"""
with pytest.raises(NotImplementedError):
self.publisher.publish_obj(self.obj)
@mock.patch.object(BaseMarketingSitePublisher, 'node_id', return_value='123')
@mock.patch.object(BaseMarketingSitePublisher, 'delete_node', return_value=None)
def test_delete_obj(self, mock_delete_node, mock_node_id):
"""
Verify that object deletion looks up the corresponding node ID and then
attempts to delete the node with that ID.
"""
self.publisher.delete_obj(self.obj)
mock_node_id.assert_called_with(self.obj)
mock_delete_node.assert_called_with('123')
@responses.activate
def test_serialize_obj(self):
"""
Verify that the base publisher serializes data required to publish any object.
"""
self.mock_api_client()
actual = self.publisher.serialize_obj(self.obj)
expected = {
'type': str(self.program.type).lower(),
'title': self.program.title,
'field_uuid': str(self.program.uuid),
'uuid': str(self.program.uuid),
'author': {
'id': self.user_id,
},
'status': 1 if self.program.status == ProgramStatus.Active else 0
'field_dummy': '2',
'author': {'id': self.user_id},
}
self.assertDictEqual(publish_data, expected)
assert actual == expected
@responses.activate
def test_get_node_id(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
publisher = MarketingSitePublisher()
node_id = publisher._get_node_id(self.api_client, self.program.uuid) # pylint: disable=protected-access
self.assert_responses_call_count(4)
self.assertEqual(node_id, self.node_id)
def test_node_id(self):
"""
Verify that node ID lookup makes a request and pulls the ID out of the
response, and raises an exception for non-200 status codes.
"""
self.mock_api_client()
lookup_value = getattr(self.obj, self.publisher.unique_field)
self.mock_node_retrieval(self.publisher.node_lookup_field, lookup_value)
node_id = self.publisher.node_id(self.obj)
assert responses.calls[-1].request.url == '{base}?{field}={value}'.format(
base=self.publisher.node_api_base,
field=self.publisher.node_lookup_field,
value=lookup_value
)
assert node_id == self.node_id
responses.reset()
self.mock_api_client()
self.mock_node_retrieval(self.publisher.node_lookup_field, lookup_value, status=500)
with pytest.raises(NodeLookupError):
self.publisher.node_id(self.obj)
@responses.activate
def test_get_non_existent_node_id(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid, exists=False)
publisher = MarketingSitePublisher()
node_id = publisher._get_node_id(self.api_client, self.program.uuid) # pylint: disable=protected-access
self.assertIsNone(node_id)
def test_create_node(self):
"""
Verify that node creation makes the correct request and returns the ID
contained in the response, and raises an exception for non-201 status codes.
"""
self.mock_api_client()
response_data = {'id': self.node_id}
self.mock_node_create(response_data, 201)
node_data = {'foo': 'bar'}
node_id = self.publisher.create_node(node_data)
assert responses.calls[-1].request.url == self.publisher.node_api_base
assert json.loads(responses.calls[-1].request.body) == node_data
assert node_id == self.node_id
responses.reset()
self.mock_api_client()
self.mock_node_create(response_data, 500)
with pytest.raises(NodeCreateError):
self.publisher.create_node(node_data)
@responses.activate
def test_edit_node(self):
self.mock_api_client(200)
"""
Verify that node editing makes the correct request and raises an exception
for non-200 status codes.
"""
self.mock_api_client()
self.mock_node_edit(200)
publisher = MarketingSitePublisher()
publish_data = publisher._get_node_data(self.program, self.user_id) # pylint: disable=protected-access
publisher._edit_node(self.api_client, self.node_id, publish_data) # pylint: disable=protected-access
self.assert_responses_call_count(4)
@responses.activate
def test_edit_node_failed(self):
self.mock_api_client(200)
node_data = {'foo': 'bar'}
self.publisher.edit_node(self.node_id, node_data)
assert responses.calls[-1].request.url == '{base}/{node_id}'.format(
base=self.publisher.node_api_base,
node_id=self.node_id
)
assert json.loads(responses.calls[-1].request.body) == node_data
responses.reset()
self.mock_api_client()
self.mock_node_edit(500)
publisher = MarketingSitePublisher()
publish_data = publisher._get_node_data(self.program, self.user_id) # pylint: disable=protected-access
with self.assertRaises(ProgramPublisherException):
publisher._edit_node(self.api_client, self.node_id, publish_data) # pylint: disable=protected-access
@responses.activate
def test_create_node(self):
self.mock_api_client(200)
self.mock_node_create(self.expected_node, 201)
publisher = MarketingSitePublisher()
publish_data = publisher._get_node_data(self.program, self.user_id) # pylint: disable=protected-access
data = publisher._create_node(self.api_client, publish_data) # pylint: disable=protected-access
self.assertEqual(data, self.expected_node['id'])
with pytest.raises(NodeEditError):
self.publisher.edit_node(self.node_id, node_data)
@responses.activate
def test_create_node_failed(self):
self.mock_api_client(200)
self.mock_node_create({}, 500)
publisher = MarketingSitePublisher()
publish_data = publisher._get_node_data(self.program, self.user_id) # pylint: disable=protected-access
with self.assertRaises(ProgramPublisherException):
publisher._create_node(self.api_client, publish_data) # pylint: disable=protected-access
def test_delete_node(self):
"""
Verify that node deletion makes the correct request and raises an exception
for non-204 status codes.
"""
self.mock_api_client()
self.mock_node_delete(200)
@responses.activate
def test_publish_program_create(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid, exists=False)
self.mock_node_create(self.expected_node, 201)
publisher = MarketingSitePublisher()
self.mock_add_alias()
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
publisher.publish_program(self.program)
self.assert_responses_call_count(7)
self.publisher.delete_node(self.node_id)
assert responses.calls[-1].request.url == '{base}/{node_id}'.format(
base=self.publisher.node_api_base,
node_id=self.node_id
)
responses.reset()
self.mock_api_client()
self.mock_node_delete(500)
with pytest.raises(NodeDeleteError):
self.publisher.delete_node(self.node_id)
class CourseRunMarketingSitePublisherTests(MarketingSitePublisherTestMixin):
"""
Tests covering course run-specific publishing logic.
"""
def setUp(self):
super().setUp()
self.partner = PartnerFactory()
self.publisher = CourseRunMarketingSitePublisher(self.partner)
self.api_root = self.publisher.client.api_url
self.username = self.publisher.client.username
self.obj = CourseRunFactory()
@mock.patch.object(CourseRunMarketingSitePublisher, 'node_id', return_value='node_id')
@mock.patch.object(CourseRunMarketingSitePublisher, 'serialize_obj', return_value='data')
@mock.patch.object(CourseRunMarketingSitePublisher, 'edit_node', return_value=None)
def test_publish_obj(self, mock_edit_node, *args): # pylint: disable=unused-argument
"""
Verify that the publisher attempts to publish when course run status changes.
"""
# No previous object. No editing should occur.
self.publisher.publish_obj(self.obj)
assert not mock_edit_node.called
# A previous object is provided, but the status hasn't changed.
# No editing should occur.
self.publisher.publish_obj(self.obj, previous_obj=self.obj)
assert not mock_edit_node.called
# A previous object is provided, and the status has changed.
# Editing should occur.
previous_obj = CourseRunFactory(status=CourseRunStatus.Unpublished)
self.publisher.publish_obj(self.obj, previous_obj=previous_obj)
mock_edit_node.assert_called_with('node_id', 'data')
@responses.activate
def test_publish_program_edit(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
publisher = MarketingSitePublisher()
self.mock_add_alias()
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
publisher.publish_program(self.program)
self.assert_responses_call_count(7)
def test_serialize_obj(self):
"""
Verify that the publisher serializes data required to publish course runs.
"""
self.mock_api_client()
actual = self.publisher.serialize_obj(self.obj)
expected = {
'field_course_id': self.obj.key,
'author': {'id': self.user_id},
'status': 1,
}
assert actual == expected
self.obj.status = CourseRunStatus.Unpublished
actual = self.publisher.serialize_obj(self.obj)
expected['status'] = 0
assert actual == expected
class ProgramMarketingSitePublisherTests(MarketingSitePublisherTestMixin):
"""
Tests covering program-specific publishing logic.
"""
def setUp(self):
super().setUp()
self.partner = PartnerFactory()
self.publisher = ProgramMarketingSitePublisher(self.partner)
self.api_root = self.publisher.client.api_url
self.username = self.publisher.client.username
self.obj = ProgramFactory()
@mock.patch.object(ProgramMarketingSitePublisher, 'serialize_obj', return_value={'uuid': 'foo'})
@mock.patch.object(ProgramMarketingSitePublisher, 'node_id', return_value='node_id')
@mock.patch.object(ProgramMarketingSitePublisher, 'create_node', return_value='node_id')
@mock.patch.object(ProgramMarketingSitePublisher, 'edit_node', return_value=None)
@mock.patch.object(ProgramMarketingSitePublisher, 'update_node_alias', return_value=None)
def test_publish_obj(self, mock_update_node_alias, mock_edit_node, mock_create_node, *args): # pylint: disable=unused-argument
"""
Verify that the publisher only attempts to publish programs of certain types,
only attempts an edit when any one of a set of trigger fields is changed,
and always follows publication with an attempt to update the node alias.
"""
# Publication isn't supported for programs of this type.
self.publisher.publish_obj(self.obj)
mocked_methods = (mock_create_node, mock_edit_node, mock_update_node_alias)
for mocked_method in mocked_methods:
assert not mocked_method.called
for name in ('MicroMasters', 'Professional Certificate'):
for mocked_method in mocked_methods:
mocked_method.reset_mock()
# Publication is supported for programs of this type. No previous object
# is provided, so node creation should occur.
self.obj.type.name = name
self.publisher.publish_obj(self.obj)
assert mock_create_node.called
assert not mock_edit_node.called
assert mock_update_node_alias.called
for mocked_method in mocked_methods:
mocked_method.reset_mock()
# A previous object is provided, but none of the trigger fields have
# changed. Editing should not occur.
self.publisher.publish_obj(self.obj, previous_obj=self.obj)
for mocked_method in mocked_methods:
assert not mocked_method.called
# Trigger fields have changed. Editing should occur.
previous_obj = ProgramFactory()
self.publisher.publish_obj(self.obj, previous_obj=previous_obj)
assert not mock_create_node.called
assert mock_edit_node.called
assert mock_update_node_alias.called
@responses.activate
def test_publish_modified_program(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
program_before = ProgramFactory()
publisher = MarketingSitePublisher(program_before)
self.mock_add_alias()
self.mock_delete_alias()
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_delete_alias_url', return_value='/foo'):
publisher.publish_program(self.program)
self.assert_responses_call_count(8)
def test_serialize_obj(self):
"""
Verify that the publisher serializes data required to publish programs.
"""
self.mock_api_client()
actual = self.publisher.serialize_obj(self.obj)
expected = {
'field_uuid': str(self.obj.uuid),
'author': {'id': self.user_id},
'status': 1,
'title': self.obj.title,
'type': str(self.obj.type).lower().replace(' ', '_'),
'uuid': str(self.obj.uuid),
}
assert actual == expected
self.obj.status = ProgramStatus.Unpublished
actual = self.publisher.serialize_obj(self.obj)
expected['status'] = 0
assert actual == expected
@responses.activate
def test_get_alias_form(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
publisher = MarketingSitePublisher()
def test_update_node_alias(self):
"""
Verify that the publisher attempts to create a new alias when necessary
and deletes an old alias, if one existed, and that appropriate exceptions
are raised for non-200 status codes.
"""
# No previous object is provided. Alias creation should occur, but alias
# deletion should not.
self.mock_api_client()
self.mock_get_alias_form()
self.mock_add_alias()
self.publisher.update_node_alias(self.obj, self.node_id, None)
assert responses.calls[-1].request.url == '{}/add'.format(self.publisher.alias_api_base)
responses.reset()
# Same scenario, but this time a non-200 status code is returned during
# alias creation. An exception should be raised.
self.mock_api_client()
self.mock_get_alias_form()
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
publisher.publish_program(self.program)
self.assert_responses_call_count(8)
self.mock_add_alias(status=500)
@responses.activate
def test_get_delete_form(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
program_before = ProgramFactory()
publisher = MarketingSitePublisher(program_before)
self.mock_add_alias()
self.mock_get_delete_form(program_before.marketing_slug)
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
publisher.publish_program(self.program)
self.assert_responses_call_count(9)
with pytest.raises(AliasCreateError):
self.publisher.update_node_alias(self.obj, self.node_id, None)
@responses.activate
def test_get_alias_form_failed(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
publisher = MarketingSitePublisher()
self.mock_add_alias()
self.mock_get_alias_form(500)
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with self.assertRaises(ProgramPublisherException):
publisher.publish_program(self.program)
responses.reset()
@responses.activate
def test_get_delete_form_failed(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
program_before = ProgramFactory()
publisher = MarketingSitePublisher(program_before)
# A previous object is provided, but the marketing slug hasn't changed.
# Neither alias creation nor alias deletion should occur.
self.mock_api_client()
self.publisher.update_node_alias(self.obj, self.node_id, self.obj)
responses.reset()
# A previous object is provided, and the marketing slug has changed.
# Both alias creation and alias deletion should occur.
previous_obj = ProgramFactory()
self.mock_api_client()
self.mock_get_alias_form()
self.mock_add_alias()
self.mock_get_delete_form(program_before.marketing_slug, 500)
with mock.patch.object(MarketingSitePublisher, '_get_headers', return_value={}):
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
with self.assertRaises(ProgramPublisherException):
publisher.publish_program(self.program)
self.mock_get_delete_form(previous_obj.marketing_slug)
self.mock_delete_alias()
@responses.activate
def test_add_alias_failed(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_edit(200)
publisher = MarketingSitePublisher()
self.mock_add_alias(500)
with mock.patch.object(MarketingSitePublisher, '_get_form_build_id_and_form_token', return_value={}):
with self.assertRaises(ProgramPublisherException):
publisher.publish_program(self.program)
self.publisher.update_node_alias(self.obj, self.node_id, previous_obj)
@responses.activate
def test_publish_unmodified_program(self):
self.mock_api_client(200)
publisher = MarketingSitePublisher(self.program)
publisher.publish_program(self.program)
self.assert_responses_call_count(0)
assert any('/add' in call.request.url for call in responses.calls)
assert any('/list/{}'.format(previous_obj.marketing_slug) in call.request.url for call in responses.calls)
@responses.activate
def test_publish_xseries_program(self):
self.program.type = ProgramType.objects.get(name='XSeries')
publisher = MarketingSitePublisher()
publisher.publish_program(self.program)
self.assert_responses_call_count(0)
responses.reset()
@responses.activate
def test_publish_program_no_credential(self):
self.program.partner.marketing_site_api_password = None
self.program.partner.marketing_site_api_username = None
publisher = MarketingSitePublisher()
with self.assertRaises(ProgramPublisherException):
publisher.publish_program(self.program)
self.assert_responses_call_count(0)
# Same scenario, but this time a non-200 status code is returned during
# alias deletion. An exception should be raised.
self.mock_api_client()
self.mock_get_alias_form()
self.mock_add_alias()
self.mock_get_delete_form(previous_obj.marketing_slug)
self.mock_delete_alias(status=500)
@responses.activate
def test_publish_delete_program(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid)
self.mock_node_delete(204)
publisher = MarketingSitePublisher()
publisher.delete_program(self.program)
self.assert_responses_call_count(5)
with pytest.raises(AliasDeleteError):
self.publisher.update_node_alias(self.obj, self.node_id, previous_obj)
@responses.activate
def test_publish_delete_non_existent_program(self):
self.mock_api_client(200)
self.mock_node_retrieval(self.program.uuid, exists=False)
publisher = MarketingSitePublisher()
publisher.delete_program(self.program)
self.assert_responses_call_count(4)
def test_alias(self):
"""
Verify that aliases are constructed correctly.
"""
actual = self.publisher.alias(self.obj)
expected = '{type}/{slug}'.format(type=self.obj.type.slug, slug=self.obj.marketing_slug)
@responses.activate
def test_publish_delete_xseries(self):
self.program = ProgramFactory(type=ProgramType.objects.get(name='XSeries'))
publisher = MarketingSitePublisher()
publisher.delete_program(self.program)
self.assert_responses_call_count(0)
assert actual == expected
course_discovery/apps/course_metadata/tests/test_signals.py deleted 100644 → 0
# pylint: disable=no-member
from unittest.mock import patch
from django.test import TestCase
from course_discovery.apps.course_metadata.models import ProgramType
from course_discovery.apps.course_metadata.tests import factories, toggle_switch
MARKETING_SITE_PUBLISHERS_MODULE = 'course_discovery.apps.course_metadata.publishers.MarketingSitePublisher'
@patch(MARKETING_SITE_PUBLISHERS_MODULE + '.delete_program')
class SignalsTest(TestCase):
def setUp(self):
super(SignalsTest, self).setUp()
self.program = factories.ProgramFactory(type=ProgramType.objects.get(name='MicroMasters'))
def test_delete_program_signal_no_publish(self, delete_program_mock):
toggle_switch('publish_program_to_marketing_site', False)
self.program.delete()
self.assertFalse(delete_program_mock.called)
def test_delete_program_signal_with_publish(self, delete_program_mock):
toggle_switch('publish_program_to_marketing_site', True)
self.program.delete()
delete_program_mock.assert_called_once_with(self.program)
course_discovery/apps/course_metadata/views.py
......@@ -28,14 +28,14 @@ class CourseRunSelectionAdmin(UpdateView):
context = super(CourseRunSelectionAdmin, self).get_context_data(**kwargs)
context.update({
'program_id': self.object.id,
'title': _('Change program excluded course runs')
'title': _('Update excluded course runs')
})
return context
raise Http404
def form_valid(self, form):
self.object = form.save()
message = 'The program course runs was changed successfully.'
message = _('The program was changed successfully.')
messages.add_message(self.request, messages.SUCCESS, message)
return HttpResponseRedirect(self.get_success_url())
......
course_discovery/conf/locale/en/LC_MESSAGES/django.po
......@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-04-20 16:51+0500\n"
"POT-Creation-Date: 2017-04-20 11:56-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
......@@ -201,6 +201,13 @@ msgid "Partners"
msgstr ""
#: apps/course_metadata/admin.py
#, python-brace-format
msgid ""
"An error occurred while publishing the {model} to the marketing site. Please"
" try again. If the error persists, please contact the Engineering Team."
msgstr ""
#: apps/course_metadata/admin.py
msgid "eligible for one-click purchase"
msgstr ""
......@@ -217,12 +224,6 @@ msgstr ""
msgid "Included course runs"
msgstr ""
#: apps/course_metadata/admin.py
msgid ""
"An error occurred while publishing the program to the marketing site. Please"
" try again. If the error persists, please contact the Engineering Team."
msgstr ""
#: apps/course_metadata/choices.py apps/publisher/choices.py
msgid "Published"
msgstr ""
......@@ -440,7 +441,11 @@ msgid "Allow courses in this program to be purchased in a single transaction"
msgstr ""
#: apps/course_metadata/views.py
msgid "Change program excluded course runs"
msgid "Update excluded course runs"
msgstr ""
#: apps/course_metadata/views.py
msgid "The program was changed successfully."
msgstr ""
#: apps/publisher/api/serializers.py
......
course_discovery/conf/locale/en/LC_MESSAGES/djangojs.po
......@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-04-20 16:51+0500\n"
"POT-Creation-Date: 2017-04-20 11:56-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
......
course_discovery/conf/locale/eo/LC_MESSAGES/django.po
......@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-04-20 16:51+0500\n"
"POT-Creation-Date: 2017-04-20 11:56-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
......@@ -242,6 +242,21 @@ msgid "Partners"
msgstr "Pärtnérs Ⱡ'σяєм ιρѕυм ∂#"
#: apps/course_metadata/admin.py
#, python-brace-format
msgid ""
"An error occurred while publishing the {model} to the marketing site. Please"
" try again. If the error persists, please contact the Engineering Team."
msgstr ""
"Àn érrör öççürréd whïlé püßlïshïng thé {model} tö thé märkétïng sïté. Pléäsé"
" trý ägäïn. Ìf thé érrör pérsïsts, pléäsé çöntäçt thé Éngïnéérïng Téäm. "
"Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє¢тєтυя α∂ιριѕι¢ιηg єłιт, ѕє∂ ∂σ єιυѕмσ∂ "
"тємρσя ιη¢ι∂ι∂υηт υт łαвσяє єт ∂σłσяє мαgηα αłιqυα. υт єηιм α∂ мιηιм νєηιαм,"
" qυιѕ ησѕтяυ∂ єχєя¢ιтαтιση υłłαм¢σ łαвσяιѕ ηιѕι υт αłιqυιρ єχ єα ¢σммσ∂σ "
"¢σηѕєqυαт. ∂υιѕ αυтє ιяυяє ∂σłσя ιη яєρяєнєη∂єяιт ιη νσłυρтαтє νєłιт єѕѕє "
"¢ιłłυм ∂σłσяє єυ ƒυgιαт ηυłłα ραяιαтυя. єχ¢єρтєυя ѕιηт σ¢¢αє¢αт ¢υρι∂αтαт "
"ηση ρяσι∂єηт, ѕυηт ιη ¢υłρα qυι σƒƒι¢ια ∂єѕєяυηт мσłłιт αηιм ι∂ єѕ#"
#: apps/course_metadata/admin.py
msgid "eligible for one-click purchase"
msgstr "élïgïßlé för öné-çlïçk pürçhäsé Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє¢т#"
......@@ -258,20 +273,6 @@ msgstr "Nö Ⱡ'σя#"
msgid "Included course runs"
msgstr "Ìnçlüdéd çöürsé rüns Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, #"
#: apps/course_metadata/admin.py
msgid ""
"An error occurred while publishing the program to the marketing site. Please"
" try again. If the error persists, please contact the Engineering Team."
msgstr ""
"Àn érrör öççürréd whïlé püßlïshïng thé prögräm tö thé märkétïng sïté. Pléäsé"
" trý ägäïn. Ìf thé érrör pérsïsts, pléäsé çöntäçt thé Éngïnéérïng Téäm. "
"Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє¢тєтυя α∂ιριѕι¢ιηg єłιт, ѕє∂ ∂σ єιυѕмσ∂ "
"тємρσя ιη¢ι∂ι∂υηт υт łαвσяє єт ∂σłσяє мαgηα αłιqυα. υт єηιм α∂ мιηιм νєηιαм,"
" qυιѕ ησѕтяυ∂ єχєя¢ιтαтιση υłłαм¢σ łαвσяιѕ ηιѕι υт αłιqυιρ єχ єα ¢σммσ∂σ "
"¢σηѕєqυαт. ∂υιѕ αυтє ιяυяє ∂σłσя ιη яєρяєнєη∂єяιт ιη νσłυρтαтє νєłιт єѕѕє "
"¢ιłłυм ∂σłσяє єυ ƒυgιαт ηυłłα ραяιαтυя. єχ¢єρтєυя ѕιηт σ¢¢αє¢αт ¢υρι∂αтαт "
"ηση ρяσι∂єηт, ѕυηт ιη ¢υłρα qυι σƒƒι¢ια ∂єѕєяυηт мσłłιт αηιм #"
#: apps/course_metadata/choices.py apps/publisher/choices.py
msgid "Published"
msgstr "Püßlïshéd Ⱡ'σяєм ιρѕυм ∂σł#"
......@@ -551,9 +552,14 @@ msgstr ""
" ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє¢тєтυя #"
#: apps/course_metadata/views.py
msgid "Change program excluded course runs"
msgid "Update excluded course runs"
msgstr "Ûpdäté éxçlüdéd çöürsé rüns Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє#"
#: apps/course_metadata/views.py
msgid "The program was changed successfully."
msgstr ""
"Çhängé prögräm éxçlüdéd çöürsé rüns Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, ¢σηѕє¢тєт#"
"Thé prögräm wäs çhängéd süççéssfüllý. Ⱡ'σяєм ιρѕυм ∂σłσя ѕιт αмєт, "
"¢σηѕє¢тєтυ#"
#: apps/publisher/api/serializers.py
#, python-brace-format
......
course_discovery/conf/locale/eo/LC_MESSAGES/djangojs.po
......@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-04-20 16:51+0500\n"
"POT-Creation-Date: 2017-04-20 11:56-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment