def setUp(self): # 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="******", password="******", facility=self.facility) self.user.save() # create an initial VideoLog instance so we have something to collide with later self.original_videolog = VideoLog(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() # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was created correctly 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 total seconds watched have already changed.")
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("blah"))
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_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 setUp(self): super(TestExerciseLogs, 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="******", facility=self.facility) self.user.set_password("dumber") self.user.save() # create an initial ExerciseLog instance so we have something to collide with 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.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.")
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_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
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 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_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 setUp(self): self.facility = Facility(name="Test Facility") self.facility.save() self.group = FacilityGroup(facility=self.facility, name="Test Class") self.group.full_clean() self.group.save() self.user = FacilityUser(facility=self.facility, username="******", first_name="Firstname", last_name="Lastname", group=self.group) self.user.clear_text_password = "******" # not used anywhere but by us, for testing purposes self.user.set_password(self.user.clear_text_password) self.user.full_clean() self.user.save()
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 # reset the group, if needed. 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 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.full_clean() 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): # 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 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 test_users_out_of_group(self): group = FacilityGroup(name="Test Group", facility=self.facility) group.save() FacilityUser(username="******", password="******", facility=self.facility).save() self.browser_login_admin() self.browse_to(self.reverse("tabular_view") + "?topic=addition-subtraction&group=" + group.id) self.browser.find_element_by_css_selector('#error_message') self.assertEqual(self.browser.find_element_by_css_selector('#error_message').text, "No users found.", "Error message with no users available.")
def test_success_with_group(self): group = FacilityGroup(name="Test Group", facility=self.facility) group.save() FacilityUser(username="******", password="******", facility=self.facility, group=group).save() self.browser_login_admin() self.browse_to(self.reverse("tabular_view") + "?topic=addition-subtraction&group=" + group.id) with self.assertRaises(NoSuchElementException): self.browser.find_element_by_css_selector('#error_message')
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)
class ChangeLocalUserPassword(unittest.TestCase): def setUp(self): self.facility = Facility(name="Test Facility") self.facility.save() self.group = FacilityGroup(facility=self.facility, name="Test Class") self.group.full_clean() self.group.save() self.user = FacilityUser(facility=self.facility, username="******", first_name="Firstname", last_name="Lastname", group=self.group) self.user.clear_text_password = "******" # not used anywhere but by us, for testing purposes self.user.set_password(self.user.clear_text_password) self.user.full_clean() self.user.save() def test_change_password(self): # Now, re-retrieve the user, to check. (out, err, val) = call_command_with_output("changelocalpassword", self.user.username, noinput=True) self.assertEquals(err, "", "no output on stderr") self.assertNotEquals(out, "", "some output on stderr") self.assertEquals(val, 0, "Exit code is zero") match = re.match( r"^.*Generated new password for user '([^']+)': '([^']+)'", out.replace("\n", ""), re.MULTILINE) self.assertFalse(match is None, "could not parse stdout") user = FacilityUser.objects.get(facility=self.facility, username=self.user.username) self.assertEquals(user.username, match.groups()[0], "Username reported correctly") self.assertTrue(user.check_password(match.groups()[1]), "New password works") self.assertFalse(user.check_password(self.user.clear_text_password), "NOT the old password") def test_no_user(self): fake_username = self.user.username + "xxxxx" #with self.assertRaises(FacilityUser.DoesNotExist): (out, err, val) = call_command_with_output("changelocalpassword", fake_username, noinput=True) self.assertNotIn("Generated new password for user", out, "Did not set password") self.assertNotEquals(err, "", "some output on stderr") match = re.match(r"^.*Error: user '([^']+)' does not exist$", err.replace("\n", ""), re.M) self.assertFalse(match is None, "could not parse stderr") self.assertEquals(match.groups()[0], fake_username, "Verify printed fake username") self.assertNotEquals(val, 0, "Verify exit code is non-zero")
def setUp(self): # 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(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 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 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="******", password="******", facility=self.facility) self.user.save() # create an initial ExerciseLog instance so we have something to collide with 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.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.")
def setUp(self): # 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="******", password="******", facility=self.facility) self.user.save() # create an initial VideoLog instance so we have something to collide with later self.original_videolog = VideoLog(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() # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was created correctly 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 total seconds watched have already changed.")
class ChangeLocalUserPassword(unittest.TestCase): def setUp(self): self.facility = Facility(name="Test Facility") self.facility.save() self.group = FacilityGroup(facility=self.facility, name="Test Class") self.group.full_clean() self.group.save() self.user = FacilityUser(facility=self.facility, username="******", first_name="Firstname", last_name="Lastname", group=self.group) self.user.clear_text_password = "******" # not used anywhere but by us, for testing purposes self.user.set_password(self.user.clear_text_password) self.user.full_clean() self.user.save() def test_change_password(self): # Now, re-retrieve the user, to check. (out,err,val) = call_command_with_output("changelocalpassword", self.user.username, noinput=True) self.assertEquals(err, "", "no output on stderr") self.assertNotEquals(out, "", "some output on stderr") self.assertEquals(val, 0, "Exit code is zero") match = re.match(r"^.*Generated new password for user '([^']+)': '([^']+)'", out.replace("\n",""), re.MULTILINE) self.assertFalse(match is None, "could not parse stdout") user = FacilityUser.objects.get(facility=self.facility, username=self.user.username) self.assertEquals(user.username, match.groups()[0], "Username reported correctly") self.assertTrue(user.check_password(match.groups()[1]), "New password works") self.assertFalse(user.check_password(self.user.clear_text_password), "NOT the old password") def test_no_user(self): fake_username = self.user.username + "xxxxx" #with self.assertRaises(FacilityUser.DoesNotExist): (out,err,val) = call_command_with_output("changelocalpassword", fake_username, noinput=True) self.assertNotIn("Generated new password for user", out, "Did not set password") self.assertNotEquals(err, "", "some output on stderr") match = re.match(r"^.*Error: user '([^']+)' does not exist$", err.replace("\n",""), re.M) self.assertFalse(match is None, "could not parse stderr") self.assertEquals(match.groups()[0], fake_username, "Verify printed fake username") self.assertNotEquals(val, 0, "Verify exit code is non-zero")
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 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, password=self.korean_string, ) 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, 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_neither_bad(self): fu = FacilityUser(username="******") dbg_mode = settings.DEBUG settings.DEBUG = True with self.assertRaises(AssertionError): fu.set_password()
class TestExerciseLogs(KALiteTestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 NEW_POINTS = 22 NEW_ATTEMPTS = 5 EXERCISE_ID = "number_line" def setUp(self): super(TestExerciseLogs, 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="******", facility=self.facility) self.user.set_password("dumber") self.user.save() # create an initial ExerciseLog instance so we have something to collide with 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.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") def test_exerciselog_update(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # update the ExerciseLog exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was updated self.assertEqual(exerciselog2.points, self.NEW_POINTS, "The ExerciseLog's points were not updated.") self.assertEqual(exerciselog2.attempts, self.NEW_ATTEMPTS, "The ExerciseLog's attempts were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_exerciselog_collision(self): # create a new exercise log with the same exercise_id and user, but different points/attempts exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS # try saving the new ExerciseLog: this is where the collision will happen, hopefully leading to a merge exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog has been properly merged self.assertEqual(exerciselog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The ExerciseLog's points were not properly merged.") self.assertEqual(exerciselog.attempts, max(self.ORIGINAL_ATTEMPTS, self.NEW_ATTEMPTS), "The ExerciseLog's attempts have already changed.")
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 handle(self, *args, **options): facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = json.load(open("./static/data/topicdata/" + topic + ".json","r")) exercises = sorted(exercises, key = lambda k: (k["h_position"], k["v_position"])) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
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 handle(self, *args, **options): facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) if settings.DEBUG: newuser1.set_password(hashed_password = hashed_blah)#"blah") else: newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) if settings.DEBUG: newuser2.set_password(hashed_password = hashed_blah)#"blah") else: newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = get_topic_exercises(topic_id=topic) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
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
class TestExerciseLogs(TestCase): ORIGINAL_POINTS = 37 ORIGINAL_ATTEMPTS = 3 NEW_POINTS = 22 NEW_ATTEMPTS = 5 EXERCISE_ID = "number_line" def setUp(self): # 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="******", password="******", facility=self.facility) self.user.save() # create an initial ExerciseLog instance so we have something to collide with 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.save() # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was saved as intended self.assertEqual(exerciselog.points, self.ORIGINAL_POINTS, "The ExerciseLog's points have already changed.") self.assertEqual(exerciselog.attempts, self.ORIGINAL_ATTEMPTS, "The ExerciseLog's attempts have already changed.") def test_exerciselog_update(self): # get a new reference to the existing ExerciseLog exerciselog = ExerciseLog.objects.get(id=self.original_exerciselog.id) # update the ExerciseLog exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog was updated self.assertEqual(exerciselog2.points, self.NEW_POINTS, "The ExerciseLog's points were not updated.") self.assertEqual(exerciselog2.attempts, self.NEW_ATTEMPTS, "The ExerciseLog's attempts were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_exerciselog_collision(self): # create a new exercise log with the same exercise_id and user, but different points/attempts exerciselog = ExerciseLog(exercise_id=self.EXERCISE_ID, user=self.user) exerciselog.points = self.NEW_POINTS exerciselog.attempts = self.NEW_ATTEMPTS # try saving the new ExerciseLog: this is where the collision will happen, hopefully leading to a merge exerciselog.save() # get a new reference to the existing ExerciseLog exerciselog2 = ExerciseLog.objects.get(id=self.original_exerciselog.id) # make sure the ExerciseLog has been properly merged self.assertEqual(exerciselog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The ExerciseLog's points were not properly merged.") self.assertEqual(exerciselog.attempts, max(self.ORIGINAL_ATTEMPTS, self.NEW_ATTEMPTS), "The ExerciseLog's attempts have already changed.")
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 TestVideoLogs(TestCase): ORIGINAL_POINTS = 37 ORIGINAL_SECONDS_WATCHED = 3 NEW_POINTS = 22 NEW_SECONDS_WATCHED = 5 YOUTUBE_ID = "aNqG4ChKShI" def setUp(self): # 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="******", password="******", facility=self.facility) self.user.save() # create an initial VideoLog instance so we have something to collide with later self.original_videolog = VideoLog(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() # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was created correctly 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 total seconds watched have already changed.") def test_videolog_update(self): # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # update the VideoLog videolog.points = self.NEW_POINTS videolog.total_seconds_watched = self.NEW_SECONDS_WATCHED videolog.save() # get a new reference to the existing VideoLog videolog2 = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was updated self.assertEqual(videolog2.points, self.NEW_POINTS, "The VideoLog's points were not updated.") self.assertEqual( videolog2.total_seconds_watched, self.NEW_SECONDS_WATCHED, "The VideoLog's total seconds watched were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_videolog_collision(self): # create a new video log with the same youtube_id and user, but different points/total seconds watched videolog = VideoLog(youtube_id=self.YOUTUBE_ID, user=self.user) videolog.points = self.NEW_POINTS videolog.total_seconds_watched = self.NEW_SECONDS_WATCHED # try saving the new VideoLog: this is where the collision will happen, hopefully leading to a merge videolog.save() # get a new reference to the existing VideoLog videolog2 = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog has been properly merged self.assertEqual(videolog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The VideoLog's points were not properly merged.") self.assertEqual( videolog.total_seconds_watched, max(self.ORIGINAL_ATTEMPTS, self.NEW_SECONDS_WATCHED), "The VideoLog's total seconds watched have already changed.")
class TestSaveVideoLog(KALiteTestCase): ORIGINAL_POINTS = 84 ORIGINAL_SECONDS_WATCHED = 32 NEW_POINTS = 32 NEW_SECONDS_WATCHED = 15 YOUTUBE_ID = "aNqG4ChKShI" YOUTUBE_ID2 = "b22tMEc6Kko" 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(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(youtube_id=self.YOUTUBE_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( 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(youtube_id=self.YOUTUBE_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( 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(youtube_id=self.YOUTUBE_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 TestSaveVideoLog(KALiteTestCase): ORIGINAL_POINTS = 84 ORIGINAL_SECONDS_WATCHED = 32 NEW_POINTS = 32 NEW_SECONDS_WATCHED = 15 YOUTUBE_ID = "aNqG4ChKShI" YOUTUBE_ID2 = "b22tMEc6Kko" 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(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(youtube_id=self.YOUTUBE_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( 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(youtube_id=self.YOUTUBE_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( 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(youtube_id=self.YOUTUBE_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.")
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("blah"))
class TestVideoLogs(KALiteTestCase): ORIGINAL_POINTS = 37 ORIGINAL_SECONDS_WATCHED = 3 NEW_POINTS = 22 NEW_SECONDS_WATCHED = 5 YOUTUBE_ID = "aNqG4ChKShI" VIDEO_ID = i18n.get_video_id(YOUTUBE_ID) or "dummy" def setUp(self): super(TestVideoLogs, 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="******", facility=self.facility) self.user.set_password("dumber") self.user.save() # create an initial VideoLog instance so we have something to collide with 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() # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was created correctly 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 total seconds watched have already changed.") def test_videolog_update(self): # get a new reference to the existing VideoLog videolog = VideoLog.objects.get(id=self.original_videolog.id) # update the VideoLog videolog.points = self.NEW_POINTS videolog.total_seconds_watched = self.NEW_SECONDS_WATCHED videolog.save() # get a new reference to the existing VideoLog videolog2 = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog was updated self.assertEqual(videolog2.points, self.NEW_POINTS, "The VideoLog's points were not updated.") self.assertEqual(videolog2.total_seconds_watched, self.NEW_SECONDS_WATCHED, "The VideoLog's total seconds watched were not updated.") @unittest.skip("Auto-merging is not yet automatic, so skip this") def test_videolog_collision(self): # create a new video log with the same youtube_id and user, but different points/total seconds watched videolog = VideoLog(video_id=self.VIDEO_ID, youtube_id=self.YOUTUBE_ID, user=self.user) videolog.points = self.NEW_POINTS videolog.total_seconds_watched = self.NEW_SECONDS_WATCHED # try saving the new VideoLog: this is where the collision will happen, hopefully leading to a merge videolog.save() # get a new reference to the existing VideoLog videolog2 = VideoLog.objects.get(id=self.original_videolog.id) # make sure the VideoLog has been properly merged self.assertEqual(videolog.points, max(self.ORIGINAL_POINTS, self.NEW_POINTS), "The VideoLog's points were not properly merged.") self.assertEqual(videolog.total_seconds_watched, max(self.ORIGINAL_ATTEMPTS, self.NEW_SECONDS_WATCHED), "The VideoLog's total seconds watched have already changed.")
def handle(self, *args, **options): if settings.CENTRAL_SERVER: raise CommandError("Don't run this on the central server!! Data not linked to any zone on the central server is BAD.") facility = Facility(name="Wilson Elementary") facility.save() group1 = FacilityGroup(facility=facility, name="Class 4E") group1.full_clean() group1.save() group2 = FacilityGroup(facility=facility, name="Class 5B") group2.full_clean() group2.save() facilityusers = [] for i in range(0,10): newuser1 = FacilityUser(facility=facility, username=usernames[i], first_name=firstnames[i], last_name=lastnames[i], group=group1) if settings.DEBUG: newuser1.set_password(hashed_password = hashed_blah)#"blah") else: newuser1.set_password("blah") newuser1.full_clean() newuser1.save() facilityusers.append(newuser1) newuser2 = FacilityUser(facility=facility, username=usernames[i+10], first_name=firstnames[i+10], last_name=lastnames[i+10], group=group2) if settings.DEBUG: newuser2.set_password(hashed_password = hashed_blah)#"blah") else: newuser2.set_password("blah") newuser2.full_clean() newuser2.save() facilityusers.append(newuser2) for topic in topics: exercises = get_topic_exercises(topic_id=topic) exercises_a = [random.random() for i in range(len(exercises))] exercises_b = [float(i) / len(exercises) for i in range(len(exercises))] for i, user in enumerate(facilityusers): for j, exercise in enumerate(exercises): sig = sigmoid(proficiency[i], exercises_a[j], exercises_b[j]) if random.random() < 0.05 * (1-sig) and j > 2: break if random.random() < 0.15: continue attempts = random.random() * 40 + 10 streak_progress = max(10, min(100, 10 * random.random() + 10 * attempts * sig)) print int(attempts), int(streak_progress), user.first_name, exercise["name"] log = ExerciseLog(user=user, exercise_id=exercise["name"], attempts=attempts, streak_progress=streak_progress) log.full_clean() log.save()
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