def test_groups_two_groups_one_user_in_group_no_ungrouped_group_selected_move(self):
facility = self.facility
params = {
"zone_id": None,
"facility_id": facility.id,
}
group_name_1 = "From Group"
group1 = FacilityGroup(name=group_name_1, facility=self.facility)
group1.save()
group_name_2 = "To Group"
group2 = FacilityGroup(name=group_name_2, facility=self.facility)
group2.save()
user = FacilityUser(username="******", facility=self.facility, group=group1)
user.set_password(raw_password="******")
user.save()
self.browser_login_admin()
self.browse_to(self.reverse("facility_management", kwargs=params))
self.browser.find_element_by_xpath("//div[@id='students']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr/td[1]/input[@type='checkbox'][1]").click()
Select(self.browser.find_element_by_css_selector("div#students select.movegrouplist")).select_by_visible_text("To Group")
self.browser.find_element_by_css_selector("button.movegroup").click()
alert = self.browser.switch_to_alert()
self.assertNotEqual(alert.text, None, "Does not produce alert of group movement.")
self.assertEqual(alert.text, "You are about to move selected users to another group.", "Does not warn that users are about to be moved.")
alert.accept()
WebDriverWait(self.browser, 5).until(EC.presence_of_element_located((By.ID, "students")))
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr[1]/td[5]").text, "0", "Does not report no user for From Group.")
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr[2]/td[5]").text, "1", "Does not report one user for To Group.")
def create_student(self, username=default_username, password=default_password, facility_name=default_facility_name):
facilities = Facility.objects.filter(name=facility_name)
facility = facilities[0] if facilities else self.create_facility()
student = FacilityUser(username=username, facility=facility)
student.set_password(raw_password=password)
student.save()
return student
def test_query_login_teacher(self):
"""Check the # of queries when logging in as a teacher."""
teacher = FacilityUser(is_teacher=True, username="******", facility=self.facility)
passwd = self._gen_valid_password()
teacher.set_password(passwd)
teacher.save()
with self.assertNumQueries(39 + 3*UserLog.is_enabled()):
self.browser_login_teacher("t1", passwd, self.facility)
def test_query_login_student(self):
"""Check the # of queries when logging in as a student."""
student = FacilityUser(is_teacher=False, username="******", facility=self.facility)
passwd = self._gen_valid_password()
student.set_password(passwd)
student.save()
with self.assertNumQueries(39 + 3*UserLog.is_enabled()):
self.browser_login_student("s1", passwd, self.facility)
def setUp(self):
"""Create a new facility and facility user"""
super(ChangeLocalUserPassword, self).setUp()
self.old_password = '******'
self.username = "******"
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.username,
facility=self.facility)
self.user.set_password(self.old_password)
self.user.save()
def test_unicode_string(self):
# Dependencies
dev = Device.get_own_device()
self.assertNotIn(unicode(dev), "Bad Unicode data", "Device: Bad conversion to unicode.")
fac = Facility(name=self.korean_string)
fac.save()
self.assertNotIn(unicode(fac), "Bad Unicode data", "Facility: Bad conversion to unicode.")
fg = FacilityGroup(facility=fac, name=self.korean_string)
fg.save()
self.assertNotIn(unicode(fg), "Bad Unicode data", "FacilityGroup: Bad conversion to unicode.")
user = FacilityUser(
facility=fac,
group=fg,
first_name=self.korean_string,
last_name=self.korean_string,
username=self.korean_string,
notes=self.korean_string,
)
user.set_password(self.korean_string * settings.PASSWORD_CONSTRAINTS["min_length"])
user.save()
self.assertNotIn(unicode(user), "Bad Unicode data", "FacilityUser: Bad conversion to unicode.")
known_classes = [ExerciseLog, UserLog, UserLogSummary, VideoLog]
#
elog = ExerciseLog(user=user, exercise_id=self.korean_string)
self.assertNotIn(unicode(elog), "Bad Unicode data", "ExerciseLog: Bad conversion to unicode (before saving).")
elog.save()
self.assertNotIn(unicode(elog), "Bad Unicode data", "ExerciseLog: Bad conversion to unicode (after saving).")
vlog = VideoLog(user=user, video_id=self.korean_string, youtube_id=self.korean_string)
self.assertNotIn(unicode(vlog), "Bad Unicode data", "VideoLog: Bad conversion to unicode (before saving).")
vlog.save()
self.assertNotIn(unicode(vlog), "Bad Unicode data", "VideoLog: Bad conversion to unicode (after saving).")
ulog = UserLog(user=user)
self.assertNotIn(unicode(ulog), "Bad Unicode data", "UserLog: Bad conversion to unicode.")
ulogsum = UserLogSummary(
user=user,
device=dev,
activity_type=1,
start_datetime=datetime.now(),
end_datetime=datetime.now(),
)
self.assertNotIn(unicode(ulogsum), "Bad Unicode data", "UserLogSummary: Bad conversion to unicode.")
def generate_fake_facility_users(nusers=20, facilities=None, facility_groups=None, password="******"):
"""Add the given fake facility users to each of the given fake facilities.
If no facilities are given, they are created."""
if not facility_groups:
(facility_groups, facilities) = generate_fake_facility_groups(facilities=facilities)
facility_users = []
cur_usernum = 0
users_per_group = nusers / len(facility_groups)
for facility in facilities:
for facility_group in facility_groups:
for i in range(0, users_per_group):
user_data = {
"first_name": random.choice(firstnames),
"last_name": random.choice(lastnames),
}
user_data["username"] = username_from_name(user_data["first_name"], user_data["last_name"])
try:
facility_user = FacilityUser.objects.get(facility=facility, username=user_data["username"])
facility_user.group = facility_group
facility_user.save()
logging.info("Retrieved facility user '%s/%s'" % (facility.name, user_data["username"]))
except FacilityUser.DoesNotExist as e:
notes = json.dumps(sample_user_settings())
facility_user = FacilityUser(
facility=facility,
username=user_data["username"],
first_name=user_data["first_name"],
last_name=user_data["last_name"],
notes=notes,
group=facility_group,
)
facility_user.set_password(password) # set same password for every user
facility_user.save()
logging.info("Created facility user '%s/%s'" % (facility.name, user_data["username"]))
facility_users.append(facility_user)
cur_usernum += 1 # this is messy and could be done more intelligently;
# could also randomize to add more users, as this function
# seems to be generic, but really is not.
return (facility_users, facility_groups, facilities)
def load_test(request, nusers=None):
global n_users_created
if not n_users_created or n_users_created < int(
request.GET.get("nusers", 1)): # default 1, as before
# It's either the first time, or time to add more
# Make sure there's a facility
if not Facility.objects.count():
fac = Facility.objects.create(name="fac")
fac = Facility.objects.all()[0]
# Loop over all needed students
while n_users_created < int(request.GET.get("nusers", 1)):
n_users_created += 1
unpw = "s%d" % n_users_created
(user, _) = FacilityUser.get_or_initialize(username=unpw,
facility=fac)
user.set_password(unpw)
user.save()
return {
"pct_videos": request.GET.get("pct_videos", 0.9),
"pct_logout": request.GET.get("pct_logout", 0.0),
"nusers": n_users_created,
}
def setUp(self):
super(TestSaveVideoLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME,
facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial VideoLog instance so we have something to update later
self.original_videolog = VideoLog(video_id=self.VIDEO_ID,
youtube_id=self.YOUTUBE_ID,
user=self.user)
self.original_videolog.points = self.ORIGINAL_POINTS
self.original_videolog.total_seconds_watched = self.ORIGINAL_SECONDS_WATCHED
self.original_videolog.save()
def setUp(self):
super(TestSaveExerciseLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME,
facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial ExerciseLog instance so we have something to update later
self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID,
user=self.user)
self.original_exerciselog.points = self.ORIGINAL_POINTS
self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS
self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS
self.original_exerciselog.save()
def test_groups_one_group_one_user_in_group_no_ungrouped_no_group_selected(self):
facility = self.facility
params = {
"zone_id": None,
"facility_id": facility.id,
}
group_name = "Test Group"
group = FacilityGroup(name=group_name, facility=self.facility)
group.save()
user = FacilityUser(username="******", facility=self.facility, group=group)
user.set_password(raw_password="******")
user.save()
self.browser_login_admin()
self.browse_to(self.reverse("facility_management", kwargs=params))
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr/td[2]/a[1]").text.strip()[:len(group.name)], "Test Group", "Does not show group in list.")
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr/td[5]").text.strip()[:len(group.name)], "1", "Does not report one user for group.")
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='students']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr/td[2]").text.strip()[:len(user.username)], "test_user", "Does not show user in list.")
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='students']/div[@class='col-md-12']/div[@class='table-responsive']/table/tbody/tr/td[5]").text.strip()[:len(user.group.name)], "Test Group", "Does not report user in group.")
class ChangeLocalUserPassword(MainTestCase):
"""Tests for the changelocalpassword command"""
def setUp(self):
"""Create a new facility and facility user"""
super(ChangeLocalUserPassword, self).setUp()
self.old_password = '******'
self.username = "******"
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.username,
facility=self.facility)
self.user.set_password(self.old_password)
self.user.save()
def test_change_password_on_existing_user(self):
"""Change the password on an existing user."""
# Now, re-retrieve the user, to check.
(out, err, val) = call_command_with_output("changelocalpassword",
self.user.username,
noinput=True)
self.assertEqual(err, "", "no output on stderr")
self.assertNotEqual(out, "", "some output on stdout")
self.assertEqual(val, 0, "Exit code is not zero")
new_password = re.search(
r"Generated new password for user .*: '(?P<password>.*)'",
out).group('password')
self.assertNotEqual(self.old_password, new_password)
c = KALiteClient()
success = c.login(username=self.user.username,
password=new_password,
facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
def test_change_password_on_nonexistent_user(self):
nonexistent_username = "******"
with self.assertRaises(CommandError):
(out, err, val) = call_command_with_output("changelocalpassword",
nonexistent_username,
noinput=True)
def setUp(self):
"""Create a new facility and facility user"""
super(ChangeLocalUserPassword, self).setUp()
self.old_password = '******'
self.username = "******"
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.username, facility=self.facility)
self.user.set_password(self.old_password)
self.user.save()
def test_groups_two_groups_one_user_in_group_no_ungrouped_group_selected_move(self):
facility = self.facility
params = {
"zone_id": None,
"facility_id": facility.id,
}
group_name_1 = "From Group"
group1 = FacilityGroup(name=group_name_1, facility=self.facility)
group1.save()
group_name_2 = "To Group"
group2 = FacilityGroup(name=group_name_2, facility=self.facility)
group2.save()
user = FacilityUser(username="******", facility=self.facility, group=group1)
user.set_password(raw_password="******")
user.save()
self.browser_login_admin()
self.browse_to(self.reverse("facility_management", kwargs=params))
self.browser.find_element_by_xpath("//div[@id='students']/table/tbody/tr/td[4]").click()
Select(self.browser.find_element_by_css_selector("div#students select.movegrouplist")).select_by_visible_text("To Group")
self.browser.find_element_by_css_selector("div#students button.movegroup").click()
alert = self.browser.switch_to_alert()
self.assertNotEqual(alert, None, "Does not produce alert of group movement.")
self.assertEqual(alert.text, "You are about to move selected users to another group.", "Does not warn that users are about to be moved.")
alert.accept()
WebDriverWait(self.browser, 5).until(EC.presence_of_element_located((By.ID, "students")))
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/table/tbody/tr[1]/td[3]").text, "0", "Does not report no user for From Group.")
self.assertEqual(self.browser.find_element_by_xpath("//div[@id='groups']/table/tbody/tr[2]/td[3]").text, "1", "Does not report one user for To Group.")
def test_groups_one_group_one_user_in_group_no_ungrouped_no_group_selected(
self):
facility = self.facility
params = {
"zone_id": None,
"facility_id": facility.id,
}
group_name = "Test Group"
group = FacilityGroup(name=group_name, facility=self.facility)
group.save()
user = FacilityUser(username="******",
facility=self.facility,
group=group)
user.set_password(raw_password="******")
user.save()
self.browser_login_admin()
self.browse_to(self.reverse("facility_management", kwargs=params))
self.assertEqual(
self.browser.find_element_by_xpath(
"//div[@id='groups']/table/tbody/tr/td[1]/a[1]").text.strip()
[:len(group.name)], "Test Group", "Does not show group in list.")
self.assertEqual(
self.browser.find_element_by_xpath(
"//div[@id='groups']/table/tbody/tr/td[3]").text.strip()
[:len(group.name)], "1", "Does not report one user for group.")
self.assertEqual(
self.browser.find_element_by_xpath(
"//div[@id='students']/table/tbody/tr[1]/td[1]").text.strip()
[:len(user.username)], "test_user", "Does not show user in list.")
self.assertEqual(
self.browser.find_element_by_xpath(
"//div[@id='students']/table/tbody/tr/td[3]").text.strip()
[:len(user.group.name)], "Test Group",
"Does not report user in group.")
def setUp(self):
super(TestSaveVideoLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME, facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial VideoLog instance so we have something to update later
self.original_videolog = VideoLog(video_id=self.VIDEO_ID, youtube_id=self.YOUTUBE_ID, user=self.user)
self.original_videolog.points = self.ORIGINAL_POINTS
self.original_videolog.total_seconds_watched = self.ORIGINAL_SECONDS_WATCHED
self.original_videolog.save()
class ChangeLocalUserPassword(MainTestCase):
"""Tests for the changelocalpassword command"""
def setUp(self):
"""Create a new facility and facility user"""
super(ChangeLocalUserPassword, self).setUp()
self.old_password = '******'
self.username = "******"
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.username, facility=self.facility)
self.user.set_password(self.old_password)
self.user.save()
def test_change_password_on_existing_user(self):
"""Change the password on an existing user."""
# Now, re-retrieve the user, to check.
(out,err,val) = call_command_with_output("changelocalpassword", self.user.username, noinput=True)
self.assertEqual(err, "", "no output on stderr")
self.assertNotEqual(out, "", "some output on stdout")
self.assertEqual(val, 0, "Exit code is not zero")
new_password = re.search(r"Generated new password for user .*: '(?P<password>.*)'", out).group('password')
self.assertNotEqual(self.old_password, new_password)
c = KALiteClient()
success = c.login(username=self.user.username, password=new_password, facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
def test_change_password_on_nonexistent_user(self):
nonexistent_username = "******"
with self.assertRaises(CommandError):
(out, err, val) = call_command_with_output("changelocalpassword", nonexistent_username, noinput=True)
def generate_fake_facility_users(nusers=20,
facilities=None,
facility_groups=None,
password="******"):
"""Add the given fake facility users to each of the given fake facilities.
If no facilities are given, they are created."""
if not facility_groups:
(facility_groups,
facilities) = generate_fake_facility_groups(facilities=facilities)
facility_users = []
cur_usernum = 0
users_per_group = nusers / len(facility_groups)
for facility in facilities:
for facility_group in facility_groups:
for i in range(0, users_per_group):
user_data = {
"first_name": random.choice(firstnames),
"last_name": random.choice(lastnames),
}
user_data["username"] = username_from_name(
user_data["first_name"], user_data["last_name"])
try:
facility_user = FacilityUser.objects.get(
facility=facility, username=user_data["username"])
facility_user.group = facility_group
facility_user.save()
logging.info("Retrieved facility user '%s/%s'" %
(facility.name, user_data["username"]))
except FacilityUser.DoesNotExist as e:
notes = json.dumps(sample_user_settings())
facility_user = FacilityUser(
facility=facility,
username=user_data["username"],
first_name=user_data["first_name"],
last_name=user_data["last_name"],
notes=notes,
group=facility_group,
)
facility_user.set_password(
password) # set same password for every user
facility_user.save()
logging.info("Created facility user '%s/%s'" %
(facility.name, user_data["username"]))
facility_users.append(facility_user)
cur_usernum += 1 # this is messy and could be done more intelligently;
# could also randomize to add more users, as this function
# seems to be generic, but really is not.
return (facility_users, facility_groups, facilities)
def setUp(self):
super(TestSaveExerciseLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME, facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial ExerciseLog instance so we have something to update later
self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user)
self.original_exerciselog.points = self.ORIGINAL_POINTS
self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS
self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS
self.original_exerciselog.save()
def test_query_login_teacher(self):
"""Check the # of queries when logging in as a teacher."""
teacher = FacilityUser(is_teacher=True,
username="******",
facility=self.facility)
passwd = self._gen_valid_password()
teacher.set_password(passwd)
teacher.save()
with self.assertNumQueries(39 + 3 * UserLog.is_enabled()):
self.browser_login_teacher("t1", passwd, self.facility)
def test_query_login_student(self):
"""Check the # of queries when logging in as a student."""
student = FacilityUser(is_teacher=False,
username="******",
facility=self.facility)
passwd = self._gen_valid_password()
student.set_password(passwd)
student.save()
with self.assertNumQueries(39 + 3 * UserLog.is_enabled()):
self.browser_login_student("s1", passwd, self.facility)
def create_student(self,
username=default_username,
password=default_password,
facility_name=default_facility_name):
facilities = Facility.objects.filter(name=facility_name)
facility = facilities[0] if facilities else self.create_facility()
student = FacilityUser(username=username, facility=facility)
student.set_password(raw_password=password)
student.save()
return student
def load_test(request, nusers=None):
global n_users_created
if not n_users_created or n_users_created < int(request.GET.get("nusers", 1)): # default 1, as before
# It's either the first time, or time to add more
# Make sure there's a facility
if not Facility.objects.count():
fac = Facility.objects.create(name="fac")
fac = Facility.objects.all()[0]
# Loop over all needed students
while n_users_created < int(request.GET.get("nusers", 1)):
n_users_created += 1
unpw = "s%d" % n_users_created
(user, _) = FacilityUser.get_or_initialize(username=unpw, facility=fac)
user.set_password(unpw)
user.save()
return {
"pct_videos": request.GET.get("pct_videos", 0.9),
"pct_logout": request.GET.get("pct_logout", 0.0),
"nusers": n_users_created,
}
class TestSaveVideoLog(KALiteTestCase):
ORIGINAL_POINTS = 84
ORIGINAL_SECONDS_WATCHED = 32
NEW_POINTS = 32
NEW_SECONDS_WATCHED = 15
YOUTUBE_ID = "aNqG4ChKShI"
VIDEO_ID = i18n.get_video_id(YOUTUBE_ID) or "dummy"
YOUTUBE_ID2 = "b22tMEc6Kko"
VIDEO_ID2 = i18n.get_video_id(YOUTUBE_ID2) or "dummy2"
USERNAME = "******"
PASSWORD = "******"
def setUp(self):
super(TestSaveVideoLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME, facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial VideoLog instance so we have something to update later
self.original_videolog = VideoLog(video_id=self.VIDEO_ID, youtube_id=self.YOUTUBE_ID, user=self.user)
self.original_videolog.points = self.ORIGINAL_POINTS
self.original_videolog.total_seconds_watched = self.ORIGINAL_SECONDS_WATCHED
self.original_videolog.save()
def test_new_videolog(self):
# make sure the target video log does not already exist
videologs = VideoLog.objects.filter(video_id=self.VIDEO_ID2, user__username=self.USERNAME)
self.assertEqual(videologs.count(), 0, "The target video log to be newly created already exists")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new video log
result = c.save_video_log(
video_id=self.VIDEO_ID2,
youtube_id=self.YOUTUBE_ID2,
total_seconds_watched=self.ORIGINAL_SECONDS_WATCHED,
points=self.NEW_POINTS,
)
self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the video log." % result.status_code)
# get a reference to the newly created VideoLog
videolog = VideoLog.objects.get(video_id=self.VIDEO_ID2, user__username=self.USERNAME)
# make sure the VideoLog was properly created
self.assertEqual(videolog.points, self.NEW_POINTS, "The VideoLog's points were not saved correctly.")
self.assertEqual(videolog.total_seconds_watched, self.ORIGINAL_SECONDS_WATCHED, "The VideoLog's seconds watched was not saved correctly.")
def test_update_videolog(self):
# get a new reference to the existing VideoLog
videolog = VideoLog.objects.get(id=self.original_videolog.id)
# make sure the VideoLog hasn't already been changed
self.assertEqual(videolog.points, self.ORIGINAL_POINTS, "The VideoLog's points have already changed.")
self.assertEqual(videolog.total_seconds_watched, self.ORIGINAL_SECONDS_WATCHED, "The VideoLog's seconds watched already changed.")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new record onto the video log, with a correct answer (increasing the points and streak)
result = c.save_video_log(
video_id=self.VIDEO_ID,
youtube_id=self.YOUTUBE_ID,
total_seconds_watched=self.ORIGINAL_SECONDS_WATCHED + self.NEW_SECONDS_WATCHED,
points=self.ORIGINAL_POINTS + self.NEW_POINTS,
)
self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the video log." % result.status_code)
# get a reference to the updated VideoLog
videolog = VideoLog.objects.get(video_id=self.VIDEO_ID, user__username=self.USERNAME)
# make sure the VideoLog was properly updated
self.assertEqual(videolog.points, self.ORIGINAL_POINTS + self.NEW_POINTS, "The VideoLog's points were not updated correctly.")
self.assertEqual(videolog.total_seconds_watched, self.ORIGINAL_SECONDS_WATCHED + self.NEW_SECONDS_WATCHED, "The VideoLog's seconds watched was not updated correctly.")
class TestSaveVideoLog(KALiteTestCase):
ORIGINAL_POINTS = 84
ORIGINAL_SECONDS_WATCHED = 32
NEW_POINTS = 32
NEW_SECONDS_WATCHED = 15
YOUTUBE_ID = "aNqG4ChKShI"
VIDEO_ID = i18n.get_video_id(YOUTUBE_ID) or "dummy"
YOUTUBE_ID2 = "b22tMEc6Kko"
VIDEO_ID2 = i18n.get_video_id(YOUTUBE_ID2) or "dummy2"
USERNAME = "******"
PASSWORD = "******"
def setUp(self):
super(TestSaveVideoLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME,
facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial VideoLog instance so we have something to update later
self.original_videolog = VideoLog(video_id=self.VIDEO_ID,
youtube_id=self.YOUTUBE_ID,
user=self.user)
self.original_videolog.points = self.ORIGINAL_POINTS
self.original_videolog.total_seconds_watched = self.ORIGINAL_SECONDS_WATCHED
self.original_videolog.save()
def test_new_videolog(self):
# make sure the target video log does not already exist
videologs = VideoLog.objects.filter(video_id=self.VIDEO_ID2,
user__username=self.USERNAME)
self.assertEqual(
videologs.count(), 0,
"The target video log to be newly created already exists")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME,
password=self.PASSWORD,
facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new video log
result = c.save_video_log(
video_id=self.VIDEO_ID2,
youtube_id=self.YOUTUBE_ID2,
total_seconds_watched=self.ORIGINAL_SECONDS_WATCHED,
points=self.NEW_POINTS,
)
self.assertEqual(
result.status_code, 200,
"An error (%d) was thrown while saving the video log." %
result.status_code)
# get a reference to the newly created VideoLog
videolog = VideoLog.objects.get(video_id=self.VIDEO_ID2,
user__username=self.USERNAME)
# make sure the VideoLog was properly created
self.assertEqual(videolog.points, self.NEW_POINTS,
"The VideoLog's points were not saved correctly.")
self.assertEqual(
videolog.total_seconds_watched, self.ORIGINAL_SECONDS_WATCHED,
"The VideoLog's seconds watched was not saved correctly.")
def test_update_videolog(self):
# get a new reference to the existing VideoLog
videolog = VideoLog.objects.get(id=self.original_videolog.id)
# make sure the VideoLog hasn't already been changed
self.assertEqual(videolog.points, self.ORIGINAL_POINTS,
"The VideoLog's points have already changed.")
self.assertEqual(videolog.total_seconds_watched,
self.ORIGINAL_SECONDS_WATCHED,
"The VideoLog's seconds watched already changed.")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME,
password=self.PASSWORD,
facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new record onto the video log, with a correct answer (increasing the points and streak)
result = c.save_video_log(
video_id=self.VIDEO_ID,
youtube_id=self.YOUTUBE_ID,
total_seconds_watched=self.ORIGINAL_SECONDS_WATCHED +
self.NEW_SECONDS_WATCHED,
points=self.ORIGINAL_POINTS + self.NEW_POINTS,
)
self.assertEqual(
result.status_code, 200,
"An error (%d) was thrown while saving the video log." %
result.status_code)
# get a reference to the updated VideoLog
videolog = VideoLog.objects.get(video_id=self.VIDEO_ID,
user__username=self.USERNAME)
# make sure the VideoLog was properly updated
self.assertEqual(videolog.points,
self.ORIGINAL_POINTS + self.NEW_POINTS,
"The VideoLog's points were not updated correctly.")
self.assertEqual(
videolog.total_seconds_watched,
self.ORIGINAL_SECONDS_WATCHED + self.NEW_SECONDS_WATCHED,
"The VideoLog's seconds watched was not updated correctly.")
class TestSaveExerciseLog(KALiteTestCase):
ORIGINAL_POINTS = 37
ORIGINAL_ATTEMPTS = 3
ORIGINAL_STREAK_PROGRESS = 20
NEW_POINTS_LARGER = 22
NEW_ATTEMPTS = 5
NEW_STREAK_PROGRESS_LARGER = 10
NEW_POINTS_SMALLER = 0
NEW_STREAK_PROGRESS_SMALLER = 0
EXERCISE_ID = "number_line"
EXERCISE_ID2 = "radius_diameter_and_circumference"
USERNAME = "******"
PASSWORD = "******"
def setUp(self):
super(TestSaveExerciseLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME,
facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial ExerciseLog instance so we have something to update later
self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID,
user=self.user)
self.original_exerciselog.points = self.ORIGINAL_POINTS
self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS
self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS
self.original_exerciselog.save()
def test_new_exerciselog(self):
# make sure the target exercise log does not already exist
exerciselogs = ExerciseLog.objects.filter(
exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME)
self.assertEqual(
exerciselogs.count(), 0,
"The target exercise log to be newly created already exists")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME,
password=self.PASSWORD,
facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new exercise log
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID2,
streak_progress=self.NEW_STREAK_PROGRESS_LARGER,
points=self.NEW_POINTS_LARGER,
correct=True,
attempts=self.NEW_ATTEMPTS,
)
self.assertEqual(
result.status_code, 200,
"An error (%d) was thrown while saving the exercise log." %
result.status_code)
# get a reference to the newly created ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID2,
user__username=self.USERNAME)
# make sure the ExerciseLog was properly created
self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER,
"The ExerciseLog's points were not saved correctly.")
self.assertEqual(
exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER,
"The ExerciseLog's streak progress was not saved correctly.")
self.assertEqual(
exerciselog.attempts, self.NEW_ATTEMPTS,
"The ExerciseLog did not have the correct number of attempts (%d)."
% self.NEW_ATTEMPTS)
def test_update_exerciselog(self):
# get a new reference to the existing ExerciseLog
exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id)
# make sure the ExerciseLog hasn't already been changed
self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS,
"The ExerciseLog's points have already changed.")
self.assertEqual(exerciselog.streak_progress,
self.ORIGINAL_STREAK_PROGRESS,
"The ExerciseLog's streak progress already changed.")
self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS,
"The ExerciseLog's attempts have already changed.")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME,
password=self.PASSWORD,
facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new record onto the exercise log, with a correct answer (increasing the points and streak)
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID,
streak_progress=self.NEW_STREAK_PROGRESS_LARGER,
points=self.NEW_POINTS_LARGER,
correct=True,
attempts=self.NEW_ATTEMPTS,
)
self.assertEqual(
result.status_code, 200,
"An error (%d) was thrown while saving the exercise log." %
result.status_code)
# get a reference to the updated ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID,
user__username=self.USERNAME)
# make sure the ExerciseLog was properly updated
self.assertEqual(
exerciselog.points, self.NEW_POINTS_LARGER,
"The ExerciseLog's points were not updated correctly.")
self.assertEqual(
exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER,
"The ExerciseLog's streak progress was not updated correctly.")
self.assertEqual(
exerciselog.attempts, self.NEW_ATTEMPTS,
"The ExerciseLog did not have the correct number of attempts (%d)."
% self.NEW_ATTEMPTS)
# save a new record onto the exercise log, with an incorrect answer (decreasing the points and streak)
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID,
streak_progress=self.NEW_STREAK_PROGRESS_SMALLER,
points=self.NEW_POINTS_SMALLER,
correct=False,
attempts=self.NEW_ATTEMPTS + 1,
)
self.assertEqual(
result.status_code, 200,
"An error (%d) was thrown while saving the exercise log." %
result.status_code)
# get a reference to the updated ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID,
user__username=self.USERNAME)
# make sure the ExerciseLog was properly updated
self.assertEqual(exerciselog.points, self.NEW_POINTS_SMALLER,
"The ExerciseLog's points were not saved correctly.")
self.assertEqual(
exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_SMALLER,
"The ExerciseLog's streak progress was not saved correctly.")
self.assertEqual(
exerciselog.attempts, self.NEW_ATTEMPTS + 1,
"The ExerciseLog did not have the correct number of attempts.")
class TestSaveExerciseLog(KALiteTestCase):
ORIGINAL_POINTS = 37
ORIGINAL_ATTEMPTS = 3
ORIGINAL_STREAK_PROGRESS = 20
NEW_POINTS_LARGER = 22
NEW_ATTEMPTS = 5
NEW_STREAK_PROGRESS_LARGER = 10
NEW_POINTS_SMALLER = 0
NEW_STREAK_PROGRESS_SMALLER = 0
EXERCISE_ID = "number_line"
EXERCISE_ID2 = "radius_diameter_and_circumference"
USERNAME = "******"
PASSWORD = "******"
def setUp(self):
super(TestSaveExerciseLog, self).setUp()
# create a facility and user that can be referred to in models across tests
self.facility = Facility(name="Test Facility")
self.facility.save()
self.user = FacilityUser(username=self.USERNAME, facility=self.facility)
self.user.set_password(self.PASSWORD)
self.user.save()
# create an initial ExerciseLog instance so we have something to update later
self.original_exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user)
self.original_exerciselog.points = self.ORIGINAL_POINTS
self.original_exerciselog.attempts = self.ORIGINAL_ATTEMPTS
self.original_exerciselog.streak_progress = self.ORIGINAL_STREAK_PROGRESS
self.original_exerciselog.save()
def test_new_exerciselog(self):
# make sure the target exercise log does not already exist
exerciselogs = ExerciseLog.objects.filter(exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME)
self.assertEqual(exerciselogs.count(), 0, "The target exercise log to be newly created already exists")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new exercise log
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID2,
streak_progress=self.NEW_STREAK_PROGRESS_LARGER,
points=self.NEW_POINTS_LARGER,
correct=True,
attempts=self.NEW_ATTEMPTS,
)
self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code)
# get a reference to the newly created ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID2, user__username=self.USERNAME)
# make sure the ExerciseLog was properly created
self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not saved correctly.")
self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not saved correctly.")
self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS)
def test_update_exerciselog(self):
# get a new reference to the existing ExerciseLog
exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id)
# make sure the ExerciseLog hasn't already been changed
self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.")
self.assertEqual(exerciselog.streak_progress, self.ORIGINAL_STREAK_PROGRESS, "The ExerciseLog's streak progress already changed.")
self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.")
c = KALiteClient()
# login
success = c.login(username=self.USERNAME, password=self.PASSWORD, facility=self.facility.id)
self.assertTrue(success, "Was not able to login as the test user")
# save a new record onto the exercise log, with a correct answer (increasing the points and streak)
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID,
streak_progress=self.NEW_STREAK_PROGRESS_LARGER,
points=self.NEW_POINTS_LARGER,
correct=True,
attempts=self.NEW_ATTEMPTS,
)
self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code)
# get a reference to the updated ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME)
# make sure the ExerciseLog was properly updated
self.assertEqual(exerciselog.points, self.NEW_POINTS_LARGER, "The ExerciseLog's points were not updated correctly.")
self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_LARGER, "The ExerciseLog's streak progress was not updated correctly.")
self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS, "The ExerciseLog did not have the correct number of attempts (%d)." % self.NEW_ATTEMPTS)
# save a new record onto the exercise log, with an incorrect answer (decreasing the points and streak)
result = c.save_exercise_log(
exercise_id=self.EXERCISE_ID,
streak_progress=self.NEW_STREAK_PROGRESS_SMALLER,
points=self.NEW_POINTS_SMALLER,
correct=False,
attempts=self.NEW_ATTEMPTS + 1,
)
self.assertEqual(result.status_code, 200, "An error (%d) was thrown while saving the exercise log." % result.status_code)
# get a reference to the updated ExerciseLog
exerciselog = ExerciseLog.objects.get(exercise_id=self.EXERCISE_ID, user__username=self.USERNAME)
# make sure the ExerciseLog was properly updated
self.assertEqual(exerciselog.points, self.NEW_POINTS_SMALLER, "The ExerciseLog's points were not saved correctly.")
self.assertEqual(exerciselog.streak_progress, self.NEW_STREAK_PROGRESS_SMALLER, "The ExerciseLog's streak progress was not saved correctly.")
self.assertEqual(exerciselog.attempts, self.NEW_ATTEMPTS + 1, "The ExerciseLog did not have the correct number of attempts.")
def test_unicode_string(self):
# Dependencies
dev = Device.get_own_device()
self.assertNotIn(unicode(dev), "Bad Unicode data",
"Device: Bad conversion to unicode.")
fac = Facility(name=self.korean_string)
fac.save()
self.assertNotIn(unicode(fac), "Bad Unicode data",
"Facility: Bad conversion to unicode.")
fg = FacilityGroup(facility=fac, name=self.korean_string)
fg.save()
self.assertNotIn(unicode(fg), "Bad Unicode data",
"FacilityGroup: Bad conversion to unicode.")
user = FacilityUser(
facility=fac,
group=fg,
first_name=self.korean_string,
last_name=self.korean_string,
username=self.korean_string,
notes=self.korean_string,
)
user.set_password(self.korean_string *
settings.PASSWORD_CONSTRAINTS["min_length"])
user.save()
self.assertNotIn(unicode(user), "Bad Unicode data",
"FacilityUser: Bad conversion to unicode.")
known_classes = [ExerciseLog, UserLog, UserLogSummary, VideoLog]
#
elog = ExerciseLog(user=user, exercise_id=self.korean_string)
self.assertNotIn(
unicode(elog), "Bad Unicode data",
"ExerciseLog: Bad conversion to unicode (before saving).")
elog.save()
self.assertNotIn(
unicode(elog), "Bad Unicode data",
"ExerciseLog: Bad conversion to unicode (after saving).")
vlog = VideoLog(user=user,
video_id=self.korean_string,
youtube_id=self.korean_string)
self.assertNotIn(
unicode(vlog), "Bad Unicode data",
"VideoLog: Bad conversion to unicode (before saving).")
vlog.save()
self.assertNotIn(
unicode(vlog), "Bad Unicode data",
"VideoLog: Bad conversion to unicode (after saving).")
ulog = UserLog(user=user)
self.assertNotIn(unicode(ulog), "Bad Unicode data",
"UserLog: Bad conversion to unicode.")
ulogsum = UserLogSummary(
user=user,
device=dev,
activity_type=1,
start_datetime=datetime.now(),
end_datetime=datetime.now(),
)
self.assertNotIn(unicode(ulogsum), "Bad Unicode data",
"UserLogSummary: Bad conversion to unicode.")
def test_set_password_hash_nodebug_bad(self):
fu = FacilityUser(username="******")
dbg_mode = settings.DEBUG; settings.DEBUG=False
with self.assertRaises(AssertionError):
fu.set_password(hashed_password=self.__class__.hashed_blah)
settings.DEBUG = dbg_mode
def test_set_password_neither_bad(self):
fu = FacilityUser(username="******")
dbg_mode = settings.DEBUG; settings.DEBUG=True
with self.assertRaises(AssertionError):
fu.set_password()
def test_set_password_hash_ok(self):
fu = FacilityUser(username="******")
dbg_mode = settings.DEBUG; settings.DEBUG=True
fu.set_password(hashed_password=self.__class__.hashed_blah)
settings.DEBUG = dbg_mode
self.assertTrue(fu.check_password("blah"))
def test_set_password_raw_ok(self):
fu = FacilityUser(username="******")
dbg_mode = settings.DEBUG; settings.DEBUG=True
fu.set_password(raw_password="******")
settings.DEBUG = dbg_mode
self.assertTrue(fu.check_password("blahblah"))
def test_set_password_both_bad(self):
fu = FacilityUser(username="******")
dbg_mode = settings.DEBUG; settings.DEBUG=True
with self.assertRaises(AssertionError):
fu.set_password(raw_password="******", hashed_password=self.__class__.hashed_blah)
settings.DEBUG = dbg_mode