def test_program_with_different_partner(self):
"""
Tests that contained programs can't be for the wrong partner
"""
partner1 = PartnerFactory()
partner2 = PartnerFactory()
program1 = factories.ProgramFactory(partner=partner1)
program2 = factories.ProgramFactory(partner=partner2,
title='partner2 program')
data = {
'partner': partner1.id,
'name': 'Name',
'org_name': 'Org',
'email': '*****@*****.**',
'programs': [program1.id, program2.id],
'pathway_type': PathwayType.INDUSTRY.value,
}
form = PathwayAdminForm(data=data)
self.assertDictEqual(
form.errors, {
'__all__': [
'These programs are for a different partner than the pathway itself: partner2 program'
]
})
def setUp(self):
super(RefreshCourseMetadataCommandTests, self).setUp()
self.partner = PartnerFactory()
partner = self.partner
self.pipeline = [
(SubjectMarketingSiteDataLoader, partner.marketing_site_url_root,
None),
(SchoolMarketingSiteDataLoader, partner.marketing_site_url_root,
None),
(SponsorMarketingSiteDataLoader, partner.marketing_site_url_root,
None),
(CourseMarketingSiteDataLoader, partner.marketing_site_url_root,
None),
(OrganizationsApiDataLoader, partner.organizations_api_url, None),
(CoursesApiDataLoader, partner.courses_api_url, None),
(EcommerceApiDataLoader, partner.ecommerce_api_url, 1),
(ProgramsApiDataLoader, partner.programs_api_url, None),
(AnalyticsAPIDataLoader, partner.analytics_url, 1),
]
self.kwargs = {'username': '******'}
# Courses must exist for the refresh_course_metadata command to use multiple threads. If there are no
# courses, the command won't risk race conditions between threads trying to create the same course.
CourseFactory(partner=self.partner)
self.mock_access_token_api()
def setUp(self):
super(TestMigrateCommentsToSalesforce, self).setUp()
self.partner = PartnerFactory()
self.user_1 = UserFactory()
self.org_1 = OrganizationFactory(partner=self.partner)
self.course_1 = CourseFactory(
partner=self.partner,
authoring_organizations=[self.org_1],
key=self.org_1.key + '+101x',
title='Old Title',
)
self.course_run_1 = CourseRunFactory(
key='course-v1:{key}+1T2019'.format(
key=self.course_1.key,
),
course=self.course_1,
)
self.publisher_course_1 = PublisherCourseFactory(number='101x', title='New Title')
self.publisher_course_1.organizations.add(self.org_1) # pylint: disable=no-member
self.publisher_course_run_1 = PublisherCourseRunFactory(
course=self.publisher_course_1,
lms_course_id='course-v1:{org}+{number}+1T2019'.format(
org=self.org_1.key, number=self.publisher_course_1.number
),
)
def setUp(self):
super(TestLoadDrupalData, self).setUp()
self.command_name = 'load_drupal_data'
self.partner = PartnerFactory()
self.course_run = CourseRunFactory(course__partner=self.partner)
self.course_run.course.canonical_course_run = self.course_run
self.course_run.course.save()
def setUp(self):
super().setUp()
self.partner = PartnerFactory()
self.partner.marketing_site_url_root = self.api_root
self.partner.marketing_site_api_username = self.username
self.partner.marketing_site_api_password = self.password
self.person = PersonFactory(partner=self.partner,
given_name='Test',
family_name='User')
self.api_client = MarketingSiteAPIClient(self.username, self.password,
self.api_root)
self.uuid = str(self.person.uuid)
self.expected_node = {
'resource': 'node',
'id': '28691',
'uuid': self.uuid,
'uri': 'https://stage.edx.org/node/28691'
}
self.expected_data = {
'type': 'person',
'title': 'Test User',
'field_person_slug': 'test-user',
'status': 1
}
def test_results_filtered_by_default_partner(self):
""" Verify the search results only include items related to the default partner if no partner is
specified on the request. If a partner is included, the data should be filtered to the requested partner. """
course_run = CourseRunFactory(course__partner=self.partner, status=CourseRunStatus.Published)
program = ProgramFactory(partner=self.partner, status=ProgramStatus.Active)
# This data should NOT be in the results
other_partner = PartnerFactory()
other_course_run = CourseRunFactory(course__partner=other_partner, status=CourseRunStatus.Published)
other_program = ProgramFactory(partner=other_partner, status=ProgramStatus.Active)
assert other_program.partner.short_code != self.partner.short_code
assert other_course_run.course.partner.short_code != self.partner.short_code
response = self.get_response()
assert response.status_code == 200
response_data = response.json()
assert response_data['objects']['results'] == \
[self.serialize_program_search(program), self.serialize_course_run_search(course_run)]
# Filter results by partner
response = self.get_response({'partner': other_partner.short_code})
assert response.status_code == 200
response_data = response.json()
assert response_data['objects']['results'] == \
[self.serialize_program_search(other_program), self.serialize_course_run_search(other_course_run)]
def test_results_filtered_by_default_partner(self):
""" Verify the search results only include items related to the default partner if no partner is
specified on the request. If a partner is included, the data should be filtered to the requested partner. """
course_run = CourseRunFactory(course__partner=self.partner,
status=CourseRunStatus.Published)
program = ProgramFactory(partner=self.partner,
status=ProgramStatus.Active)
# This data should NOT be in the results
other_partner = PartnerFactory()
other_course_run = CourseRunFactory(course__partner=other_partner,
status=CourseRunStatus.Published)
other_program = ProgramFactory(partner=other_partner,
status=ProgramStatus.Active)
self.assertNotEqual(other_program.partner.short_code,
self.partner.short_code)
self.assertNotEqual(other_course_run.course.partner.short_code,
self.partner.short_code)
response = self.get_response()
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode('utf-8'))
self.assertListEqual(response_data['objects']['results'], [
self.serialize_program(program),
self.serialize_course_run(course_run)
])
# Filter results by partner
response = self.get_response({'partner': other_partner.short_code})
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode('utf-8'))
self.assertListEqual(response_data['objects']['results'], [
self.serialize_program(other_program),
self.serialize_course_run(other_course_run)
])
def setUpClass(cls):
super(TestAlgoliaProxyWithEdxPartner, cls).setUpClass()
Partner.objects.all().delete()
Site.objects.all().delete()
cls.site = SiteFactory(id=settings.SITE_ID, domain=TEST_DOMAIN)
cls.edxPartner = PartnerFactory(site=cls.site)
cls.edxPartner.name = 'edX'
def setUp(self):
super().setUp()
self.partner = PartnerFactory(marketing_site_api_password=None)
self.course1 = CourseFactory(partner=self.partner, draft=False)
self.course2 = CourseFactory(partner=self.partner, draft=False)
self.course1UnpublishedRun = CourseRunFactory(course=self.course1, status=CourseRunStatus.Unpublished)
self.course1PublishedRun = CourseRunFactory(course=self.course1, status=CourseRunStatus.Published)
self.course2PublishedRun = CourseRunFactory(course=self.course2, status=CourseRunStatus.Published)
def setUp(self):
super(RateLimitingTest, self).setUp()
PartnerFactory(pk=settings.DEFAULT_PARTNER_ID)
self.url = reverse('api_docs')
self.user = UserFactory()
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUpClass(cls):
super().setUpClass()
Site.objects.all().delete()
cls.site = SiteFactory(id=settings.SITE_ID, domain=TEST_DOMAIN)
cls.partner = PartnerFactory(site=cls.site)
cls.request = RequestFactory(SERVER_NAME=cls.site.domain).get('')
cls.request.site = cls.site
def test_api_docs(self, admin_client):
"""
Verify that the API docs are available to authenticated clients.
"""
PartnerFactory(pk=settings.DEFAULT_PARTNER_ID)
response = admin_client.get(self.path)
assert response.status_code == 200
def setUp(self):
super(CourseStateTests, self).setUp()
self.site = SiteFactory()
self.partner = PartnerFactory(site=self.site)
self.course = self.course_state.course
self.course.image = make_image_file('test_banner.jpg')
self.course.save()
self.course.organizations.add(factories.OrganizationExtensionFactory().organization)
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()
def test_list_include_all_partners(self):
""" Verify the endpoint returns a list of all course runs for all partners. """
site1 = SiteFactory()
partner1 = PartnerFactory(site=site1)
site2 = SiteFactory()
partner2 = PartnerFactory(site=site2)
CourseRunFactory(course__partner=partner1)
CourseRunFactory(course__partner=partner2)
url = reverse('api:v1:course_run-list')
url += '?include_all_partners=1'
with self.assertNumQueries(17):
response = self.client.get(url)
assert response.status_code == 200
self.assertListEqual(
response.data['results'],
self.serialize_course_run(CourseRun.objects.all().order_by(
Lower('key')),
many=True))
def setUp(self):
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
self.obj = DummyObject()
def setUp(self):
super().setUp()
self.partner = PartnerFactory(marketing_site_api_password=None)
self.course1 = CourseFactory(partner=self.partner)
self.course2 = CourseFactory(partner=self.partner)
self.course1.url_slug_history.create(course=self.course1,
url_slug='older_course1_slug',
partner=self.partner)
self.course1.url_redirects.create(course=self.course1,
partner=self.partner,
value='/courses/course1')
self.course2.url_redirects.create(course=self.course2,
partner=self.partner,
value='/courses/course2')
def setUp(self):
super(RefreshCourseMetadataCommandTests, self).setUp()
self.partner = PartnerFactory()
partner = self.partner
self.pipeline = [
(CoursesApiDataLoader, partner.courses_api_url, None),
(EcommerceApiDataLoader, partner.ecommerce_api_url, 1),
(ProgramsApiDataLoader, partner.programs_api_url, None),
(AnalyticsAPIDataLoader, partner.analytics_url, 1),
]
# Courses must exist for the refresh_course_metadata command to use multiple threads. If there are no
# courses, the command won't risk race conditions between threads trying to create the same course.
CourseFactory(partner=self.partner)
self.mock_access_token()
def setUp(self):
super(RefreshCourseMetadataCommandTests, self).setUp()
self.partner = PartnerFactory()
partner = self.partner
self.pipeline = [(SubjectMarketingSiteDataLoader, partner.marketing_site_url_root, None),
(SchoolMarketingSiteDataLoader, partner.marketing_site_url_root, None),
(SponsorMarketingSiteDataLoader, partner.marketing_site_url_root, None),
(PersonMarketingSiteDataLoader, partner.marketing_site_url_root, None),
(CourseMarketingSiteDataLoader, partner.marketing_site_url_root, None),
(OrganizationsApiDataLoader, partner.organizations_api_url, None),
(CoursesApiDataLoader, partner.courses_api_url, None),
(EcommerceApiDataLoader, partner.ecommerce_api_url, 1),
(ProgramsApiDataLoader, partner.programs_api_url, None),
(XSeriesMarketingSiteDataLoader, partner.marketing_site_url_root, None)]
self.kwargs = {'username': '******'}
self.mock_access_token_api()
def test_program_with_same_partner(self):
"""
Test happy path with same program partner as parent pathway
"""
partner1 = PartnerFactory()
program1 = factories.ProgramFactory(partner=partner1)
data = {
'partner': partner1.id,
'name': 'Name',
'org_name': 'Org',
'email': '*****@*****.**',
'programs': [program1.id]
}
form = PathwayAdminForm(data=data)
self.assertDictEqual(form.errors, {})
def test_access_token(self):
""" Verify the property retrieves, and caches, an access token from the OAuth 2.0 provider. """
token = 'abc123'
partner = PartnerFactory()
url = '{root}/access_token'.format(root=partner.oauth2_provider_url)
body = {
'access_token': token,
'expires_in': 3600,
}
responses.add(responses.POST, url, json=body, status=200)
assert partner.access_token == token
assert len(responses.calls) == 1
# No HTTP calls should be made if the access token is cached.
responses.reset()
assert partner.access_token == token
def setUp(self):
super(CourseRunStateTests, self).setUp()
language_tag = LanguageTag(code='te-st', name='Test Language')
language_tag.save()
self.site = SiteFactory()
self.partner = PartnerFactory(site=self.site)
self.course_run.transcript_languages.add(language_tag)
self.course_run.language = language_tag
self.course_run.is_micromasters = True
self.course_run.micromasters_name = 'test'
self.course_run.lms_course_id = 'course-v1:edX+DemoX+Demo_Course'
self.course_run.save()
self.course.course_state.name = CourseStateChoices.Approved
self.course.save()
self.course_run.staff.add(PersonFactory())
self.course_run_state.preview_accepted = False
self.course_run_state.save()
self.assertTrue(self.course_run_state.can_send_for_review())
def setUp(self):
super(MarketingSitePublisherTests, self).setUp()
self.partner = PartnerFactory()
self.partner.marketing_site_url_root = self.api_root
self.partner.marketing_site_api_username = self.username
self.partner.marketing_site_api_password = self.password
self.api_client = MarketingSiteAPIClient(
self.username,
self.password,
self.api_root
)
self.expected_node = {
'resource': 'node', ''
'id': '28691',
'uuid': '18d5542f-fa80-418e-b416-455cfdeb4d4e',
'uri': 'https://stage.edx.org/node/28691'
}
self.data = {
'given_name': 'test',
'family_name': 'user'
}
def test_typeahead_partner_filter(self):
""" Ensure that a partner param limits results to that partner. """
course_runs = []
programs = []
for partner in ['edx', 'other']:
title = 'Belongs to partner ' + partner
partner = PartnerFactory(short_code=partner)
course_runs.append(
CourseRunFactory(title=title,
course=CourseFactory(partner=partner)))
programs.append(
ProgramFactory(title=title,
partner=partner,
status=ProgramStatus.Active))
response = self.get_response({'q': 'partner'}, 'edx')
self.assertEqual(response.status_code, 200)
edx_course_run = course_runs[0]
edx_program = programs[0]
self.assertDictEqual(
response.data, {
'course_runs': [self.serialize_course_run(edx_course_run)],
'programs': [self.serialize_program(edx_program)]
})
def partner(db, site): # pylint: disable=redefined-outer-name,unused-argument
skip_if_no_django()
return PartnerFactory(site=site)
def test_do_not_index_if_partner_not_edx(self):
course = self.create_course_with_basic_active_course_run()
course.partner = PartnerFactory()
course.authoring_organizations.add(OrganizationFactory())
assert not course.should_index
def test_do_not_index_if_partner_not_edx(self):
program = AlgoliaProxyProgramFactory(partner=PartnerFactory())
program.authoring_organizations.add(OrganizationFactory())
self.attach_archived_course(program=program)
assert not program.should_index
def test_str(self):
""" Verify the method returns the name of the Partner. """
partner = PartnerFactory()
self.assertEqual(str(partner), partner.name)
def test_has_marketing_site(self, marketing_site_url_root, expected):
partner = PartnerFactory(marketing_site_url_root=marketing_site_url_root)
self.assertEqual(partner.has_marketing_site, expected) # pylint: disable=no-member
def partner(db, site): # pylint: disable=unused-argument
skip_if_no_django()
return PartnerFactory(site=site)
