def setUp(self):
super().setUp()
self.site = SiteFactory()
self.site_config = SiteConfigurationFactory(site=self.site)
self.program = ProgramFactory(site=self.site)
self.certificate = self.cert_factory.create(
program_uuid=self.program.uuid, site=self.site)
self.username = "******"
self.user = UserFactory(username=self.username)
self.user_cred = self.issuer.issue_credential(self.certificate,
self.username)
self.attributes = [{
"name": "whitelist_reason",
"value": "Reason for whitelisting."
}]
def setUp(self):
super().setUp()
self.user = UserFactory(username=self.MOCK_USER_DATA['username'])
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.course = CourseFactory(site=self.site)
self.course_runs = [
CourseRunFactory(course=self.course) for _ in range(3)
]
self.user_grade_low = UserGradeFactory(
username=self.MOCK_USER_DATA['username'],
course_run=self.course_runs[0],
letter_grade='A',
percent_grade=0.70)
self.user_grade_high = UserGradeFactory(
username=self.MOCK_USER_DATA['username'],
course_run=self.course_runs[1],
letter_grade='C',
percent_grade=1.00)
self.user_grade_revoked_cert = UserGradeFactory(
username=self.MOCK_USER_DATA['username'],
course_run=self.course_runs[2],
letter_grade='B',
percent_grade=.80)
self.course_certs = [
CourseCertificateFactory(course_id=course_run.key, site=self.site)
for course_run in self.course_runs
]
self.credential_content_type = ContentType.objects.get(
app_label='credentials', model='coursecertificate')
self.user_credentials = [
UserCredentialFactory(
username=self.MOCK_USER_DATA['username'],
credential_content_type=self.credential_content_type,
credential=course_cert) for course_cert in self.course_certs
]
self.user_credentials[2].status = UserCredential.REVOKED
self.org_names = ['CCC', 'AAA', 'BBB']
self.orgs = [
OrganizationFactory(name=name, site=self.site)
for name in self.org_names
]
self.program = ProgramFactory(course_runs=self.course_runs,
authoring_organizations=self.orgs,
site=self.site)
def setUp(self):
super().setUp()
self.user = UserFactory(username=self.USERNAME)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.program = None
self.program_cert = None
mail.outbox = []
# Setup program and default email config
self._setup_program_and_program_cert("Example Program")
self.default_config = ProgramCompletionEmailConfiguration.objects.create(
identifier="default",
html_template="<h1>Default Template</h1>",
plaintext_template="Default Template",
enabled=True,
)
def setUp(self):
super().setUp()
self.program_certificate = factories.ProgramCertificateFactory(site=self.site)
self.signatory_1 = factories.SignatoryFactory()
self.signatory_2 = factories.SignatoryFactory()
self.program_certificate.signatories.add(self.signatory_1, self.signatory_2)
self.user_credential = factories.UserCredentialFactory(
username=self.MOCK_USER_DATA["username"], credential=self.program_certificate
)
self.visible_date_attr = factories.UserCredentialAttributeFactory(
user_credential=self.user_credential,
name="visible_date",
value="1970-01-01T01:01:01Z",
)
self.platform_name = self.site.siteconfiguration.platform_name
user = UserFactory(username=self.MOCK_USER_DATA["username"])
self.client.login(username=user.username, password=USER_PASSWORD)
def setUp(self):
super().setUp()
dump_random_state()
self.user = UserFactory(username=self.USERNAME)
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.program = ProgramFactory(site=self.site)
self.pathway = PathwayFactory(site=self.site, programs=[self.program])
self.pc = ProgramCertificateFactory(site=self.site,
program_uuid=self.program.uuid)
self.pcr = ProgramCertRecordFactory(program=self.program,
user=self.user)
self.data = {"username": self.USERNAME, "pathway_id": self.pathway.id}
self.url = reverse("records:share_program",
kwargs={"uuid": self.program.uuid.hex})
self.request = APIRequestFactory().get("/")
mail.outbox = []
def test_send_learner_email_only_once(self, mock_send_learner_email):
"""
Verify that we call `send_program_certificate_created_message` only once if a
certificate already exists and is being awarded again after being revoked.
"""
username = "******"
user = UserFactory(username=username)
self.site_config.records_enabled = False
self.site_config.save()
self.issuer.issue_credential(self.certificate, user.username)
# revoke the user credential
user_credential = UserCredential.objects.get(username=username)
user_credential.revoke()
# issue the credential again, make sure that we haven't tried to send the email again
self.issuer.issue_credential(self.certificate, user.username)
self.assertEqual(mock_send_learner_email.call_count, 1)
def test_existing_and_non_existing_users(self):
"""
Tests a mix of existing and non existing users. Users that don't exist
in this service are also treated as a success because no work needs to
be done changing their username.
"""
random_users = [UserFactory() for _ in range(5)]
fake_usernames = ["myname_" + str(x) for x in range(5)]
existing_users = [{user.username: user.username + '_new'} for user in random_users]
non_existing_users = [{username: username + '_new'} for username in fake_usernames]
data = {
"username_mappings": existing_users + non_existing_users
}
expected_response = {
'failed_replacements': [],
'successful_replacements': existing_users + non_existing_users
}
response = self.call_api(self.service_user, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, expected_response)
def setUp(self):
super().setUp()
self.user = UserFactory(username=self.MOCK_USER_DATA["username"])
self.client.login(username=self.user.username, password=USER_PASSWORD)
self.course = CourseFactory(site=self.site)
self.course_runs = [CourseRunFactory(course=self.course) for _ in range(3)]
self.user_grade_low = UserGradeFactory(
username=self.MOCK_USER_DATA["username"],
course_run=self.course_runs[0],
letter_grade="A",
percent_grade=0.70,
)
self.user_grade_high = UserGradeFactory(
username=self.MOCK_USER_DATA["username"],
course_run=self.course_runs[1],
letter_grade="C",
percent_grade=1.00,
)
self.user_grade_revoked_cert = UserGradeFactory(
username=self.MOCK_USER_DATA["username"],
course_run=self.course_runs[2],
letter_grade="B",
percent_grade=0.80,
)
self.course_certs = [
CourseCertificateFactory(course_id=course_run.key, site=self.site) for course_run in self.course_runs
]
self.credential_content_type = ContentType.objects.get(app_label="credentials", model="coursecertificate")
self.user_credentials = [
UserCredentialFactory(
username=self.MOCK_USER_DATA["username"],
credential_content_type=self.credential_content_type,
credential=course_cert,
)
for course_cert in self.course_certs
]
self.user_credentials[2].status = UserCredential.REVOKED
self.org_names = ["CCC", "AAA", "BBB"]
self.orgs = [OrganizationFactory(name=name, site=self.site) for name in self.org_names]
self.program = ProgramFactory(course_runs=self.course_runs, authoring_organizations=self.orgs, site=self.site)
self.program_cert_record = ProgramCertRecordFactory.create(user=self.user, program=self.program)
def test_auth(self):
""" Verify the endpoint only works with the service worker """
data = {
"username_mappings": [
{"test_username_1": "test_new_username_1"},
{"test_username_2": "test_new_username_2"}
]
}
# Test unauthenticated
response = self.client.post(self.url)
self.assertEqual(response.status_code, 401)
# Test non-service worker
random_user = UserFactory()
response = self.call_api(random_user, data)
self.assertEqual(response.status_code, 403)
# Test service worker
response = self.call_api(self.service_user, data)
self.assertEqual(response.status_code, 200)
def test_leeway(self, claim, offset):
"""
Verify that the service allows the specified amount of leeway (in
seconds) when nonzero and validating "exp" and "iat" claims.
"""
authentication = JwtAuthentication()
user = UserFactory()
jwt_value = self.generate_id_token(
user, **{claim: int(time.time()) + offset})
request = APIRequestFactory().get(
'dummy', HTTP_AUTHORIZATION='JWT {}'.format(jwt_value))
# with no leeway, these requests should not be authenticated
with mock.patch.object(drf_jwt_settings, 'JWT_LEEWAY', 0):
with self.assertRaises(AuthenticationFailed):
authentication.authenticate(request)
# with enough leeway, these requests should be authenticated
with mock.patch.object(drf_jwt_settings, 'JWT_LEEWAY', abs(offset)):
self.assertEqual((user, jwt_value),
authentication.authenticate(request))
def setUp(self):
super().setUp()
dump_random_state()
self.user = UserFactory(username=self.MOCK_USER_DATA["username"])
self.orgs = [OrganizationFactory.create(name=name, site=self.site) for name in ["TestOrg1", "TestOrg2"]]
self.course = CourseFactory.create(site=self.site)
self.course_runs = CourseRunFactory.create_batch(2, course=self.course)
self.program = ProgramFactory(
title="TestProgram1", course_runs=self.course_runs, authoring_organizations=self.orgs, site=self.site
)
self.course_certs = [
CourseCertificateFactory.create(
course_id=course_run.key,
site=self.site,
)
for course_run in self.course_runs
]
self.program_cert = ProgramCertificateFactory.create(program_uuid=self.program.uuid, site=self.site)
self.course_credential_content_type = ContentType.objects.get(
app_label="credentials", model="coursecertificate"
)
self.program_credential_content_type = ContentType.objects.get(
app_label="credentials", model="programcertificate"
)
self.course_user_credentials = [
UserCredentialFactory.create(
username=self.user.username,
credential_content_type=self.course_credential_content_type,
credential=course_cert,
)
for course_cert in self.course_certs
]
self.program_user_credential = UserCredentialFactory.create(
username=self.user.username,
credential_content_type=self.program_credential_content_type,
credential=self.program_cert,
)
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUp(self):
super().setUp()
self.user = UserFactory(username=self.MOCK_USER_DATA['username'])
self.orgs = [
OrganizationFactory.create(name=name, site=self.site)
for name in ['TestOrg1', 'TestOrg2']
]
self.course = CourseFactory.create(site=self.site)
self.course_runs = [
CourseRunFactory.create(course=self.course) for _ in range(2)
]
self.program = ProgramFactory(course_runs=self.course_runs,
authoring_organizations=self.orgs,
site=self.site)
self.course_certs = [
CourseCertificateFactory.create(
course_id=course_run.key,
site=self.site,
) for course_run in self.course_runs
]
self.program_cert = ProgramCertificateFactory.create(
program_uuid=self.program.uuid, site=self.site)
self.course_credential_content_type = ContentType.objects.get(
app_label='credentials', model='coursecertificate')
self.program_credential_content_type = ContentType.objects.get(
app_label='credentials', model='programcertificate')
self.course_user_credentials = [
UserCredentialFactory.create(
username=self.user.username,
credential_content_type=self.course_credential_content_type,
credential=course_cert) for course_cert in self.course_certs
]
self.program_user_credentials = UserCredentialFactory.create(
username=self.user.username,
credential_content_type=self.program_credential_content_type,
credential=self.program_cert)
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUp(self):
super(ManagementViewTests, self).setUp()
self.user = UserFactory(is_staff=True, is_superuser=True)
self.client.login(username=self.user.username, password=USER_PASSWORD)
def test_authenticated(self):
""" Verify the view raises `PermissionDenied` if the request is authenticated. """
user = UserFactory()
self.request.user = user
self.assertRaises(PermissionDenied, api_docs_permission_denied_handler,
self.request)
def setUp(self):
super(CredentialViewSetTests, self).setUp()
self.user = UserFactory()
Switch.objects.update_or_create(
name=DISABLE_API_SITE_FILTERING_SWITCH_NAME,
defaults={'active': False})
def test_issue_credential_with_attributes(self):
""" Verify credentials can be issued with attributes."""
UserFactory(username='******')
user_credential = self.issuer.issue_credential(self.certificate, 'testuser2', attributes=self.attributes)
self._assert_usercredential_fields(user_credential, self.certificate, 'testuser2', 'awarded', self.attributes)
def setUp(self):
super().setUp()
self.user = UserFactory()
self.staff_user = UserFactory(is_staff=True)
self.superuser = UserFactory(is_superuser=True)
def setUp(self):
super(UserTests, self).setUp()
self.user = UserFactory()
def setUp(self):
super().setUp()
self.user = UserFactory(full_name="Bart")
def setUp(self):
super().setUp()
self.user = UserFactory(username=self.MOCK_USER_DATA["username"])
self.client.login(username=self.user.username, password=USER_PASSWORD)
def setUp(self):
super().setUp()
self.service_user = UserFactory(username=self.SERVICE_USERNAME)
self.url = reverse("api:v2:replace_usernames")
def test_masquerade_banner_will_appear_for_staff(self, page):
""" Verify that staff will see the masquerade bar. """
staff = UserFactory(username="******", is_staff=True)
self.client.login(username=staff.username, password=USER_PASSWORD)
response = self._render_page(page)
self.assertContains(response, "MasqueradeBannerFactory")
def setUp(self):
super(UtilsTests, self).setUp()
self.user = UserFactory(full_name='Bart')
def setUp(self):
super().setUp()
self.user = UserFactory()
def setUp(self):
super(ThrottlingTests, self).setUp()
self.throttle = CredentialRateThrottle()
self.user = UserFactory()
def setUp(self):
super(CredentialViewSetTests, self).setUp()
self.user = UserFactory()
def setUp(self):
self.user = UserFactory(username=self.MOCK_USER_DATA['username'])
self.client.login(username=self.user.username, password=USER_PASSWORD)