+
+ {% block categories %}
+ {% if current_page.publisher_is_draft or not current_page|is_empty_placeholder:"program_categories" %}
+
-{% endblock subheader_content %}
+
+
+ {% endif %}
+ {% endblock categories %}
+ {% with category_variant="badge" is_keywords_property=True %}
+ {% placeholder "program_categories" or %}
+
+ {% trans "No associated categories" %}
+
+ {% endplaceholder %}
+ {% endwith %}
+
+ {% render_model current_page "title" %}
-
+ {% placeholder "program_excerpt" or %}
+
+{% endblock subheader_content %}
- {% trans "No excerpt content" %}
+ {% endplaceholder %}
-
-{% block content %}{% spaceless %}
-
-
+
- {% if current_page.publisher_is_draft %}
-
+
+
- {% placeholder_as_plugins "program_cover" as plugins or %}
-
+ {% with program=current_page.program %}
+ {% if program.duration or program.effort %}
+ {% trans "Cover" %}
- {% endplaceholder_as_plugins %} +
+
+ {% endif %}
+ {% endwith %}
+
- {% endif %}
+ -
+ {% if program.duration or current_page.publisher_is_draft %}
+
- + + {% trans "Duration:" %} {{ program.get_duration_display|default:"NA" }} + + {% endif %} + {% if program.effort or current_page.publisher_is_draft %} +
- + + + {% trans "Effort:" %} {{ program.get_effort_display|default:"NA" }} + + + {% course_programs_count current_page as program_count %} + {% if program_count > 0 %} +
- + + {% trans "Curriculum:" %} + {% blocktrans count counter=program_count %} {{ counter }} course {% plural %} {{ counter }} courses {% endblocktrans %} + + {% endif %} + {% if program.price %} +
- + + {% trans "Price:" %} {{ program.price_with_currency }} + + {% endif %} + {% endif %} +
+ {% placeholder "program_organizations" or %}
+
+
+ {% trans "No organizations for this program" %}
+ {% endplaceholder %} +
- {% placeholder "program_excerpt" or %}
+{% block content %}{% spaceless %}
+
+
+ {% block cover %}
+ {% placeholder_as_plugins "program_cover" as cover_plugins %}
+
+ {% if current_page.publisher_is_draft %}
+
-{% endspaceless %}{% endblock content %}
+{% endspaceless %}{% endblock content %}
\ No newline at end of file
diff --git a/src/richie/apps/courses/templatetags/extra_tags.py b/src/richie/apps/courses/templatetags/extra_tags.py
index cd0cff4e28..46804f8734 100644
--- a/src/richie/apps/courses/templatetags/extra_tags.py
+++ b/src/richie/apps/courses/templatetags/extra_tags.py
@@ -346,6 +346,20 @@ def course_runs_list_widget_props(context):
)
+@register.simple_tag(takes_context=True)
+def course_programs_count(context, page: Page):
+ """
+ Return a count of the number of courses in a program page
+ """
+ language = context["LANGUAGE_CODE"]
+
+ return len(
+ page.get_placeholders()
+ .get(slot="program_courses")
+ .get_plugins_list(language=language)
+ )
+
+
@register.filter
@stringfilter
def trim(value):
diff --git a/src/richie/apps/demo/defaults.py b/src/richie/apps/demo/defaults.py
index bc1930c59c..446727a709 100644
--- a/src/richie/apps/demo/defaults.py
+++ b/src/richie/apps/demo/defaults.py
@@ -24,6 +24,9 @@
"blogpost_tags": 1,
"programs": 6,
"programs_courses": 4,
+ "programs_organizations": 1,
+ "programs_categories": 1,
+ "programs_persons": 2,
"home_blogposts": 5,
"home_courses": 7,
"home_organizations": 4,
diff --git a/src/richie/apps/demo/management/commands/create_demo_site.py b/src/richie/apps/demo/management/commands/create_demo_site.py
index c55e28cd13..b6c9393b6f 100755
--- a/src/richie/apps/demo/management/commands/create_demo_site.py
+++ b/src/richie/apps/demo/management/commands/create_demo_site.py
@@ -424,6 +424,15 @@ def create_footer_link(**link_info):
fill_cover=pick_image("cover"),
fill_excerpt=True,
fill_body=True,
+ fill_categories=[
+ *random.sample(subjects, defaults.NB_OBJECTS["programs_categories"])
+ ],
+ fill_organizations=[
+ *random.sample(organizations, defaults.NB_OBJECTS["programs_organizations"])
+ ],
+ fill_team=[
+ *random.sample(persons, defaults.NB_OBJECTS["programs_persons"])
+ ],
fill_courses=[
*random.sample(courses, defaults.NB_OBJECTS["programs_courses"])
],
diff --git a/tests/apps/courses/test_models_program.py b/tests/apps/courses/test_models_program.py
index 82b1b60115..6808f87fc2 100644
--- a/tests/apps/courses/test_models_program.py
+++ b/tests/apps/courses/test_models_program.py
@@ -2,12 +2,22 @@
Unit tests for the Program model
"""
+from decimal import Decimal
+
+from django.core.exceptions import ValidationError
from django.test import TestCase
+from django.test.client import RequestFactory
+from django.test.utils import override_settings
+from django.utils import translation
-from cms.api import create_page
+from cms.api import add_plugin, create_page
+from richie.apps.core.factories import PageFactory
+from richie.apps.courses import factories
from richie.apps.courses.models import Program
+# pylint: disable=too-many-public-methods
+
class ProgramModelsTestCase(TestCase):
"""
@@ -23,3 +33,590 @@ def test_models_program_str(self):
program = Program(extended_object=page)
with self.assertNumQueries(1):
self.assertEqual(str(program), "Program: My first program")
+
+ # Fields: price
+
+ def test_models_program_field_price_default(self):
+ """The effort field should default to None."""
+ program = Program.objects.create(extended_object=PageFactory())
+ self.assertEqual(program.price, Decimal("0.00"))
+
+ def test_models_program_field_price_invalid(self):
+ """The price should be a positive decimal number."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(price=-1)
+ self.assertEqual(
+ context.exception.messages[0],
+ "Ensure this value is greater than or equal to 0.",
+ )
+
+ def test_models_program_field_price_null(self):
+ """The price field can be null."""
+ program = factories.ProgramFactory(price=None)
+ self.assertIsNone(program.price)
+ self.assertEqual(program.price_with_currency, "")
+
+ def test_models_program_field_price_with_currency(self):
+ """The price with currency should be a string."""
+ program = factories.ProgramFactory(price=1)
+ self.assertEqual(program.price_with_currency, "€1.00")
+
+ # Fields: effort
+
+ def test_models_program_field_effort_null(self):
+ """The effort field can be null."""
+ program = factories.ProgramFactory(effort=None)
+ self.assertIsNone(program.effort)
+ self.assertEqual(program.get_effort_display(), "")
+
+ def test_models_program_field_effort_invalid(self):
+ """An effort should be a pair: number, time unit."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(effort=[5])
+ self.assertEqual(
+ context.exception.messages[0],
+ "A composite duration should be a pair: number and time unit.",
+ )
+
+ def test_models_program_field_effort_integer(self):
+ """The first value of the effort pair should be an integer."""
+ for value in ["a", "1.0"]:
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(effort=[value, "hour"])
+ self.assertEqual(
+ context.exception.messages[0],
+ "A composite duration should be a round number of time units.",
+ )
+
+ def test_models_program_field_effort_positive(self):
+ """The first value should be a positive integer."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(effort=[-1, "hour"])
+ self.assertEqual(
+ context.exception.messages[0], "A composite duration should be positive."
+ )
+
+ def test_models_program_field_effort_invalid_unit(self):
+ """The second value should be a valid time unit choice."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(effort=[1, "invalid"])
+ self.assertEqual(
+ context.exception.messages[0],
+ "invalid is not a valid choice for a time unit.",
+ )
+
+ def test_models_program_field_effort_display_singular(self):
+ """Validate that a value of 1 time unit is displayed as expected."""
+ program = factories.ProgramFactory(effort=[1, "hour"])
+ self.assertEqual(program.get_effort_display(), "1 hour")
+
+ def test_models_program_field_effort_display_plural(self):
+ """Validate that a plural number of time units is displayed as expected."""
+ program = factories.ProgramFactory(effort=[2, "hour"])
+ self.assertEqual(program.get_effort_display(), "2 hours")
+
+ def test_models_program_field_effort_display_request(self):
+ """
+ When used in the `render_model` template tag, it should not break when passed a
+ request argument (the DjangoCMS frontend editing does it).
+ """
+ program = factories.ProgramFactory(effort=[1, "hour"])
+ request = RequestFactory().get("/")
+ self.assertEqual(program.get_effort_display(request), "1 hour")
+
+ def test_models_program_field_effort_default(self):
+ """The effort field should default to None."""
+ program = Program.objects.create(extended_object=PageFactory())
+ self.assertIsNone(program.effort)
+
+ # Fields: duration
+
+ def test_models_program_field_duration_null(self):
+ """The duration field can be null."""
+ program = factories.ProgramFactory(duration=None)
+ self.assertIsNone(program.duration)
+ self.assertEqual(program.get_duration_display(), "")
+
+ def test_models_program_field_duration_invalid(self):
+ """The duration should be a pair: number and unit."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(duration=5)
+ self.assertEqual(
+ context.exception.messages[0],
+ "A composite duration should be a pair: number and time unit.",
+ )
+
+ def test_models_program_field_duration_integer(self):
+ """The first value of the duration pair should be an integer."""
+ for value in ["a", "1.0"]:
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(duration=[value, "minute"])
+ self.assertEqual(
+ context.exception.messages[0],
+ "A composite duration should be a round number of time units.",
+ )
+
+ def test_models_program_field_duration_positive(self):
+ """The first value should be a positive integer."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(duration=[-1, "day"])
+ self.assertEqual(
+ context.exception.messages[0], "A composite duration should be positive."
+ )
+
+ def test_models_program_field_duration_invalid_unit(self):
+ """The second value should be a valid time unit choice."""
+ with self.assertRaises(ValidationError) as context:
+ factories.ProgramFactory(duration=[1, "invalid"])
+ self.assertEqual(
+ context.exception.messages[0],
+ "invalid is not a valid choice for a time unit.",
+ )
+
+ def test_models_program_field_duration_display_singular(self):
+ """Validate that a value of 1 time unit is displayed as expected."""
+ program = factories.ProgramFactory(duration=[1, "day"])
+ self.assertEqual(program.get_duration_display(), "1 day")
+
+ def test_models_program_field_duration_display_plural(self):
+ """Validate that a plural number of time units is displayed as expected."""
+ program = factories.ProgramFactory(duration=[2, "day"])
+ self.assertEqual(program.get_duration_display(), "2 days")
+
+ def test_models_program_field_duration_display_request(self):
+ """
+ When used in the `render_model` template tag, it should not break when passed a
+ request argument (the DjangoCMS frontend editing does it).
+ """
+ program = factories.ProgramFactory(duration=[1, "week"])
+ request = RequestFactory().get("/")
+ self.assertEqual(program.get_duration_display(request), "1 week")
+
+ def test_models_program_field_duration_default(self):
+ """The duration field should default to None."""
+ program = Program.objects.create(extended_object=PageFactory())
+ self.assertIsNone(program.duration)
+
+ # Organizations
+
+ def test_models_program_get_organizations_empty(self):
+ """
+ For a course not linked to any organzation the method `get_organizations` should
+ return an empty query.
+ """
+ program = factories.ProgramFactory(should_publish=True)
+ self.assertFalse(program.get_organizations().exists())
+ self.assertFalse(program.public_extension.get_organizations().exists())
+
+ def test_models_program_get_organizations(self):
+ """
+ The `get_organizations` method should return all organizations linked to a course and
+ should respect publication status.
+ """
+ # The 2 first organizations are grouped in one variable name and will be linked to the
+ # course in the following, the third category will not be linked so we can check that
+ # only the organizations linked to the course are retrieved (its name starts with `_`
+ # because it is not used and only here for unpacking purposes)
+ *draft_organizations, _other_draft = factories.OrganizationFactory.create_batch(
+ 3
+ )
+ (
+ *published_organizations,
+ _other_public,
+ ) = factories.OrganizationFactory.create_batch(3, should_publish=True)
+ program = factories.ProgramFactory(
+ fill_organizations=draft_organizations + published_organizations,
+ should_publish=True,
+ )
+
+ self.assertEqual(
+ list(program.get_organizations()),
+ draft_organizations + published_organizations,
+ )
+ self.assertEqual(
+ list(program.public_extension.get_organizations()), published_organizations
+ )
+
+ def test_models_program_get_organizations_language_current(self):
+ """
+ The `get_organizations` method should only return organizations linked to a course by
+ a plugin in the current language.
+ """
+ organization_fr = factories.OrganizationFactory(page_languages=["fr"])
+ organization_en = factories.OrganizationFactory(page_languages=["en"])
+
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(
+ slot="program_organizations"
+ )
+
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="OrganizationPlugin",
+ page=organization_en.extended_object,
+ )
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="OrganizationPlugin",
+ page=organization_fr.extended_object,
+ )
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_organizations()), [organization_fr])
+
+ with translation.override("en"):
+ self.assertEqual(list(program.get_organizations()), [organization_en])
+
+ @override_settings(
+ LANGUAGES=(("en", "en"), ("fr", "fr"), ("de", "de")),
+ CMS_LANGUAGES={
+ "default": {
+ "public": True,
+ "hide_untranslated": False,
+ "redirect_on_fallback": False,
+ "fallbacks": ["en", "fr", "de"],
+ }
+ },
+ )
+ def test_models_program_get_organizations_language_fallback(self):
+ """
+ The `get_organizations` method should return organizations linked to a course by
+ a plugin in fallback language by order of falling back.
+ """
+ (
+ organization1,
+ organization2,
+ organization3,
+ ) = factories.OrganizationFactory.create_batch(3, should_publish=True)
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(
+ slot="program_organizations"
+ )
+
+ # Plugin lookups should fallback up to the second priority language
+ add_plugin(
+ language="de",
+ placeholder=placeholder,
+ plugin_type="OrganizationPlugin",
+ **{"page": organization1.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_organizations()), [organization1])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_organizations()), [organization1])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_organizations()), [organization1])
+
+ # Plugin lookups should fallback to the first priority language if available
+ # and ignore the second priority language unless it is the current language
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="OrganizationPlugin",
+ **{"page": organization2.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_organizations()), [organization2])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_organizations()), [organization2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_organizations()), [organization1])
+
+ # Reverse plugin lookups should stick to the current language if available and
+ # ignore plugins on fallback languages
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="OrganizationPlugin",
+ **{"page": organization3.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_organizations()), [organization3])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_organizations()), [organization2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_organizations()), [organization1])
+
+ # Category
+
+ def test_models_program_get_categories_empty(self):
+ """
+ For a course not linked to any category the method `get_categories` should
+ return an empty query.
+ """
+ program = factories.ProgramFactory(should_publish=True)
+ self.assertFalse(program.get_categories().exists())
+ self.assertFalse(program.public_extension.get_categories().exists())
+
+ def test_models_program_get_categories(self):
+ """
+ The `get_categories` method should return all categories linked to a course and
+ should respect publication status.
+ """
+ # The 2 first categories are grouped in one variable name and will be linked to the
+ # course in the following, the third category will not be linked so we can check that
+ # only the categories linked to the course are retrieved (its name starts with `_`
+ # because it is not used and only here for unpacking purposes)
+ *draft_categories, _other_draft = factories.CategoryFactory.create_batch(3)
+ *published_categories, _other_public = factories.CategoryFactory.create_batch(
+ 3, should_publish=True
+ )
+ program = factories.ProgramFactory(
+ fill_categories=draft_categories + published_categories, should_publish=True
+ )
+
+ self.assertEqual(
+ list(program.get_categories()), draft_categories + published_categories
+ )
+ self.assertEqual(
+ list(program.public_extension.get_categories()), published_categories
+ )
+
+ def test_models_program_get_categories_language(self):
+ """
+ The `get_categories` method should only return categories linked to a course by
+ a plugin in the current language.
+ """
+ category_fr = factories.CategoryFactory(page_languages=["fr"])
+ category_en = factories.CategoryFactory(page_languages=["en"])
+
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(
+ slot="program_categories"
+ )
+
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="CategoryPlugin",
+ page=category_en.extended_object,
+ )
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="CategoryPlugin",
+ page=category_fr.extended_object,
+ )
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_categories()), [category_fr])
+
+ with translation.override("en"):
+ self.assertEqual(list(program.get_categories()), [category_en])
+
+ @override_settings(
+ LANGUAGES=(("en", "en"), ("fr", "fr"), ("de", "de")),
+ CMS_LANGUAGES={
+ "default": {
+ "public": True,
+ "hide_untranslated": False,
+ "redirect_on_fallback": False,
+ "fallbacks": ["en", "fr", "de"],
+ }
+ },
+ )
+ def test_models_program_get_categories_language_fallback(self):
+ """
+ The `get_categories` method should return categories linked to a course by
+ a plugin in fallback language by order of falling back.
+ """
+ category1, category2, category3 = factories.CategoryFactory.create_batch(
+ 3, should_publish=True
+ )
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(
+ slot="program_categories"
+ )
+
+ # Plugin lookups should fallback up to the second priority language
+ add_plugin(
+ language="de",
+ placeholder=placeholder,
+ plugin_type="CategoryPlugin",
+ **{"page": category1.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_categories()), [category1])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_categories()), [category1])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_categories()), [category1])
+
+ # Plugin lookups should fallback to the first priority language if available
+ # and ignore the second priority language unless it is the current language
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="CategoryPlugin",
+ **{"page": category2.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_categories()), [category2])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_categories()), [category2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_categories()), [category1])
+
+ # Reverse plugin lookups should stick to the current language if available and
+ # ignore plugins on fallback languages
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="CategoryPlugin",
+ **{"page": category3.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_categories()), [category3])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_categories()), [category2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_categories()), [category1])
+
+ # Instructors
+
+ def test_models_program_get_persons_empty(self):
+ """
+ For a course not linked to any person the method `get_persons` should
+ return an empty query.
+ """
+ program = factories.ProgramFactory(should_publish=True)
+ self.assertFalse(program.get_persons().exists())
+ self.assertFalse(program.public_extension.get_persons().exists())
+
+ def test_models_program_get_persons(self):
+ """
+ The `get_persons` method should return all persons linked to a course and
+ should respect publication status.
+ """
+ # The 2 first persons are grouped in one variable name and will be linked to the
+ # course in the following, the third person will not be linked so we can check that
+ # only the persons linked to the course are retrieved (its name starts with `_`
+ # because it is not used and only here for unpacking purposes)
+ *draft_persons, _other_draft = factories.PersonFactory.create_batch(3)
+ *published_persons, _other_public = factories.PersonFactory.create_batch(
+ 3, should_publish=True
+ )
+ program = factories.ProgramFactory(
+ fill_team=draft_persons + published_persons, should_publish=True
+ )
+
+ self.assertEqual(list(program.get_persons()), draft_persons + published_persons)
+ self.assertEqual(
+ list(program.public_extension.get_persons()), published_persons
+ )
+
+ def test_models_program_get_persons_language(self):
+ """
+ The `get_persons` method should only return persons linked to a course by a plugin
+ in the current language.
+ """
+ person_fr = factories.PersonFactory(page_languages=["fr"])
+ person_en = factories.PersonFactory(page_languages=["en"])
+
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(slot="program_team")
+
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="PersonPlugin",
+ page=person_en.extended_object,
+ )
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="PersonPlugin",
+ page=person_fr.extended_object,
+ )
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_persons()), [person_fr])
+
+ with translation.override("en"):
+ self.assertEqual(list(program.get_persons()), [person_en])
+
+ @override_settings(
+ LANGUAGES=(("en", "en"), ("fr", "fr"), ("de", "de")),
+ CMS_LANGUAGES={
+ "default": {
+ "public": True,
+ "hide_untranslated": False,
+ "redirect_on_fallback": False,
+ "fallbacks": ["en", "fr", "de"],
+ }
+ },
+ )
+ def test_models_program_get_persons_language_fallback(self):
+ """
+ The `get_persons` method should return persons linked to a course by
+ a plugin in fallback language by order of falling back.
+ """
+ person1, person2, person3 = factories.PersonFactory.create_batch(
+ 3, should_publish=True
+ )
+ program = factories.ProgramFactory(should_publish=True)
+ placeholder = program.extended_object.placeholders.get(slot="program_team")
+
+ # Plugin lookups should fallback up to the second priority language
+ add_plugin(
+ language="de",
+ placeholder=placeholder,
+ plugin_type="PersonPlugin",
+ **{"page": person1.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_persons()), [person1])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_persons()), [person1])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_persons()), [person1])
+
+ # Plugin lookups should fallback to the first priority language if available
+ # and ignore the second priority language unless it is the current language
+ add_plugin(
+ language="fr",
+ placeholder=placeholder,
+ plugin_type="PersonPlugin",
+ **{"page": person2.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_persons()), [person2])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_persons()), [person2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_persons()), [person1])
+
+ # Reverse plugin lookups should stick to the current language if available and
+ # ignore plugins on fallback languages
+ add_plugin(
+ language="en",
+ placeholder=placeholder,
+ plugin_type="PersonPlugin",
+ **{"page": person3.extended_object},
+ )
+ with translation.override("en"):
+ self.assertEqual(list(program.get_persons()), [person3])
+
+ with translation.override("fr"):
+ self.assertEqual(list(program.get_persons()), [person2])
+
+ with translation.override("de"):
+ self.assertEqual(list(program.get_persons()), [person1])
diff --git a/tests/apps/courses/test_templatetags_extra_tags_course_programs_count.py b/tests/apps/courses/test_templatetags_extra_tags_course_programs_count.py
new file mode 100644
index 0000000000..26693507b3
--- /dev/null
+++ b/tests/apps/courses/test_templatetags_extra_tags_course_programs_count.py
@@ -0,0 +1,53 @@
+"""
+Unit tests for the `course_programs_count` template filter.
+"""
+
+from django.test import RequestFactory
+
+from cms.test_utils.testcases import CMSTestCase
+
+from richie.apps.courses import factories
+from richie.apps.courses.templatetags.extra_tags import course_programs_count
+
+
+class CourseProgramsCountTagTestCase(CMSTestCase):
+ """
+ Unit test suite to validate the behavior of the `course_programs_count` tag.
+ """
+
+ def test_templatetags_course_programs_count_tag_with_published_courses(self):
+ """
+ The tag should return the number of courses available in
+ a program page
+ """
+
+ (*published_courses, _other_public) = factories.CourseFactory.create_batch(
+ 3, should_publish=True
+ )
+
+ program = factories.ProgramFactory(
+ fill_courses=published_courses, should_publish=True
+ )
+
+ request = RequestFactory().get("/")
+ request.current_page = program.extended_object
+
+ context = {"program": program, "request": request, "LANGUAGE_CODE": "en"}
+
+ self.assertEqual(
+ course_programs_count(context, request.current_page), len(published_courses)
+ )
+
+ def test_templatetags_course_programs_count_tag_without_courses(self):
+ """
+ The tag should return 0 if there are no courses available in
+ a program page
+ """
+ program = factories.ProgramFactory(should_publish=True)
+
+ request = RequestFactory().get("/")
+ request.current_page = program.extended_object
+
+ context = {"program": program, "request": request, "LANGUAGE_CODE": "en"}
+
+ self.assertEqual(course_programs_count(context, request.current_page), 0)
+
+ {% endif %}
+ {% endblock cover %}
+
+
+ 
+ {% endblockplugin %}
+
+ {% trans 'Glimpse cover' %}
+ {% if not cover_plugins %} +{% trans 'Add an image for program cover on its glimpse.' %}
+ {% endif %} + {% blockplugin cover_plugins.0 %} +
+
-
+ {% placeholder "program_body" or %}
+ - {% trans "No excerpt content" %} + {% trans "No body content" %}
{% endplaceholder %}
- {% placeholder "program_body" or %}
+ {% if current_page.publisher_is_draft or not current_page|is_empty_placeholder:"program_objectives" %}
+
{% endif %}
+
+ {% block team %}
+ {% if current_page.publisher_is_draft or not current_page|is_empty_placeholder:"program_team" %}
+
+
+ {% endif %}
{% if current_page.publisher_is_draft or not current_page|is_empty_placeholder:"program_courses" %}
+
{% blocktrans context "program_objectives__title" %}What you will learn{% endblocktrans %}
+ {% placeholder "program_objectives" or %}- {% trans "No body content" %} + {% trans "No program objectives" %}
{% endplaceholder %}
@@ -90,5 +199,35 @@
{% trans "Related courses" %}
+
+
+
+ {% endif %}
+ {% endblock team %}
+
+
+ {% block information %}
+ {% if current_page.publisher_is_draft or not current_page|is_empty_placeholder:"program_information" %}
+ + {% blocktrans context "course_detail__title" %}Program instructors{% endblocktrans %} +
+ {% with header_level=3 %} +
+ {% placeholder "program_team" page or %}
+
+ {% endwith %}
+ {% trans 'Who are the instructors for this program?' %}
+ {% endplaceholder %} +
+
+ {% endif %}
+ {% endblock information %}
+ {% placeholder "program_information" %}
+
+