def test_weird_chars_large_set(db_test_client, random_roles=True):
from application import db
username = "******"
password = "******"
first = "ääöäöpöpäÖPLÄPLÄ"
last = "ÄÅÄÖÖÖÄÅ,.1,.,ösa"
db.insert_user(username, password, first, last)
a1 = db.get_user(username, password)
assert a1.first_name == first
assert a1.last_name == last
null = db.get_user("something", "something")
assert null == None
usernames = []
passwords = []
firsts = []
lasts = []
roles = []
for i in range(20):
username = get_random_unicode(30)
password = get_random_unicode(30)
first = get_random_unicode(20)
last = get_random_unicode(35)
usernames.append(username)
passwords.append(password)
firsts.append(first)
lasts.append(last)
if random_roles:
role = choice(["USER", "TEACHER"])
else:
a = ["TEACHER", "USER"]
role = a[i % 2]
roles.append(role)
db.insert_user(username, password, first, last, role=role)
ids = []
for username, password, first, last, role in zip(usernames, passwords,
firsts, lasts, roles):
acc = db.get_user(username, password)
assert acc is not None
assert acc.last_name == last
assert acc.first_name == first
assert acc.role == role
acc2 = db.get_user_by_id(acc.id)
assert acc2.id == acc.id
assert acc.id not in ids
assert acc.last_name == acc2.last_name
assert acc.first_name == acc2.first_name
assert acc.role == acc2.role
assert acc.name == acc2.name
ids.append(acc.id)
return ids
def test_large_course_insert(db_test_client):
from application import db
teachers = []
for _ in range(random.randint(18,23)):
username = get_random_unicode(35)
password = get_random_unicode(30)
first = get_random_unicode(15)
last = get_random_unicode(25)
db.insert_user(username, password, first, last, role="TEACHER")
acc = db.get_user(username, password)
assert acc.name == username
assert acc.role == "TEACHER"
teachers.append(acc)
teach_courses = {}
for t in teachers:
teach_courses[t.id]=[]
for _ in range(random.randint(12,20)):
course = Course(get_random_unicode(20), get_random_unicode(40), random_datetime())
id, code = db.insert_course(course, t.id)
course.id = id
course.code = code
teach_courses[t.id].append(course)
random.shuffle(teachers)
for t in teachers:
db_courses = db.select_courses_teacher(t.id)
assert len(db_courses)>=12
case = unittest.TestCase()
case.assertCountEqual(db_courses, teach_courses[t.id])
return teachers
def index():
tour_count = 0
if g.user:
user = get_user(g.user['id'])
tour_count = get_user_tours_count(g.user['id'],
date.today().year)['count_tours']
if request.method == "POST":
tour_date = request.form["tour_date"] # Henter ut verdien
insert_tour(g.user['id'], tour_date)
flash('Tur registrert!')
# TODO: Så må en lagre dette i tabellen, med innlogget bruker
# TODO: Mulig ta en til egen side når en har registrert turen?
# TODO: Må vise antall turer i år mm.
date_from = date.today().replace(day=1, month=1)
date_to = date.today()
# TODO: Fortsett for måned og uke
top_users = get_top_users(date_from, date_to)
latest_tours = get_tours_latest()
today = date.today()
return render_template("index.html", **locals())
def user_tours(user_id, year):
user = get_user(user_id)
tours = get_user_tours(user_id, date(year, 1, 1), date(year, 12, 31))
#tour_count = get_user_tours_count(user_id,date.today().year)['count_tours']
#return render_template('user/user_index.html', user=user, tour_count=tour_count)
return render_template('user/user_tours.html', user=user, tours=tours)
def test_course_set_assignment_visibility(db_test_client,
a_files=[],
t_files=[]):
from application import db
from .course_test import test_course_insert
id, _ = test_course_insert(db_test_client)
teacher = db.get_user("opettaja", "opettaja")
visble_a_name = get_random_unicode(30)
visble_reveal = pytz.utc.localize(
datetime.datetime.utcnow()) - datetime.timedelta(hours=1)
visble_deadline = random_datetime(start=visble_reveal)
visble_a_id = db.insert_assignment(teacher.id, id, visble_a_name,
visble_deadline, visble_reveal, a_files)
a_name2 = get_random_unicode(30)
reveal2 = pytz.utc.localize(
datetime.datetime.utcnow()) + datetime.timedelta(hours=1)
deadline2 = random_datetime(start=visble_reveal)
a_id2 = db.insert_assignment(teacher.id, id, a_name2, deadline2, reveal2,
a_files)
points = random.randint(5, 20)
t_desc = get_random_unicode(30)
db.insert_task(teacher.id, visble_a_id, t_desc, points, t_files)
points = random.randint(5, 20)
t_desc = get_random_unicode(30)
db.insert_task(teacher.id, a_id2, t_desc, points, t_files)
cs = db.select_courses_teacher(teacher.id)
assert len(cs) == 1
c = cs[0]
assert isinstance(c, Course)
db.set_assignments(c, for_student=True)
assert len(
c.assignments) == 1, "can't see assignment that should be visible"
assert isinstance(c.assignments[0], Assignment)
assert c.assignments[0].id == visble_a_id, "assignment incorrect"
assert c.assignments[0].name == visble_a_name, "assignment incorrect"
assert c.assignments[0].reveal == visble_reveal, "assignment incorrect"
assert c.assignments[0].deadline == visble_deadline, "assignment incorrect"
cs = db.select_courses_teacher(teacher.id)
assert len(cs) == 1
c = cs[0]
assert isinstance(c, Course)
db.set_assignments(c, for_student=False)
assert len(c.assignments) == 2
first = Assignment(visble_a_id, visble_a_name,
visble_reveal.replace(tzinfo=None),
visble_deadline.replace(tzinfo=None), [])
assert first in c.assignments
second = Assignment(a_id2, a_name2, reveal2.replace(tzinfo=None),
deadline2.replace(tzinfo=None), [])
assert second in c.assignments
def user_index(user_id=-1):
#user_id = g.user["id"] # Dette er innlogget bruker
user = get_user(user_id)
tour_count = get_user_tours_count(user_id,
date.today().year)['count_tours']
# TODO: Legg også til initial_tours hvis brukeren er opprettet i år.
return render_template('user/user_index.html',
user=user,
tour_count=tour_count)
def test_select_file_details_multiple(db_test_client):
from application import db
db.insert_user("turha", "turha", "turha", "turha", role="TEACHER")
user_id = db.get_user("turha","turha").id
case = unittest.TestCase()
case.maxDiff = None
c_id, _ =db.insert_course(Course("something","somthing", datetime.datetime.now()),user_id)
for _ in range(20):
id_dic = create_dummy(db, user_id=user_id, course=c_id)
correct_files= []
for i in range(20):
rand_bytes= os.urandom(20)
name = "task"+str(id_dic["task_id"])+str(i)
id = file_insert_helper(db,binary_file=rand_bytes, task_id=id_dic["task_id"], name=name, user_id=user_id)
correct_files.append(File(id, name, datetime.datetime.now()))
files = db.select_file_details(task_id=id_dic["task_id"])
assert len(files) == 20
case.assertCountEqual(files, correct_files)
correct_bytes, _ = db.get_file(id)
assert rand_bytes == correct_bytes
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,submit_id=id_dic["submit_id"], name="submit_id"+str(id_dic["submit_id"]), user_id=user_id)
sub_id = id_dic["submit_id"]
files = db.select_file_details(submit_id=sub_id)
assert len(files) == 1
assert files[0].name == "submit_id"+str(id_dic["submit_id"])
assert files[0].id == id
correct_bytes, _ = db.get_file(id)
assert rand_bytes == correct_bytes
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,assignment_id=id_dic["assignment_id"], name="assignment_id"+str(id_dic["task_id"]), user_id=user_id)
files = db.select_file_details(assignment_id=id_dic["assignment_id"])
assert len(files) == 1
assert files[0].name == "assignment_id"+str(id_dic["assignment_id"])
assert files[0].id == id
correct_bytes, _ = db.get_file(id)
assert rand_bytes == correct_bytes
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,answer_id=id_dic["answer_id"], name="answer_id"+str(id_dic["task_id"]), user_id=user_id)
files = db.select_file_details(answer_id=id_dic["answer_id"])
assert len(files) == 1
assert files[0].name == "answer_id"+str(id_dic["answer_id"])
assert files[0].id == id
correct_bytes, _ = db.get_file(id)
assert rand_bytes == correct_bytes
def test_simple_file_assignment_task(db_test_client):
from application import db
from .assignment_test import test_simple_assignment
with generate_random_file() as temp, generate_random_file() as task_temp:
file_name = get_random_unicode(10)
task_file_name = get_random_unicode(10)
werk_file = FileStorage(temp, file_name)
werk_task_file = FileStorage(task_temp, task_file_name)
test_simple_assignment(db_test_client)
teach = db.get_user("opettaja", "opettaja")
c = db.select_courses_teacher(teach.id)[0]
name = get_random_unicode(10)
reveal = pytz.utc.localize(datetime.datetime.now())
deadline = random_datetime()
a_id = db.insert_assignment(teach.id, c.id, name, deadline, reveal, [werk_file])
task_name = get_random_unicode(10)
points = random.randint(5,100)
t_id = db.insert_task(teach.id, a_id, task_name, points, [werk_task_file])
files = db.select_file_details(assignment_id=a_id)
assert len(files)==1
file = files[0]
assert file.name == secure_filename(file_name)
assert file.date.date() == datetime.date.today()
temp.seek(0)
bin_data = temp.read()
db_bin_data, name=db.get_file(file.id)
assert name == file.name
assert len(bin_data) > 1000
assert len(bin_data)==len(db_bin_data)
assert type(bin_data)==type(db_bin_data), "Wrong types (can't compare) "+str(type(bin_data))+" vs "+str(type(db_bin_data))
assert bin_data==db_bin_data
task_files = db.select_file_details(task_id=t_id)
assert len(task_files)==1
file = task_files[0]
task_temp.seek(0)
real_task_bin_data = task_temp.read()
db_bin_task_data, name = db.get_file(file.id)
assert name == secure_filename(task_file_name)
assert real_task_bin_data == db_bin_task_data
def test_db_file_insert_constraint(db_test_client):
from application import db
s="nothing"
db.insert_user(s,s,s,s,role="TEACHER")
user_id = db.get_user(s,s).get_id()
with pytest.raises(IntegrityError):
file_insert_helper(db, user_id=user_id, binary_file=io.BytesIO(b"helvetin turhia bitteja").read())
sql = Select([db.file])
with db.engine.connect() as conn:
rs = conn.execute(sql)
row = rs.first()
assert row is None
def test_select_file_details_single(db_test_client):
from application import db
db.insert_user("turha", "turha", "turha", "turha", role="TEACHER")
user_id = db.get_user("turha","turha").id
c_id, _ =db.insert_course(Course("something","somthing", datetime.datetime.now()),user_id)
for _ in range(20):
id_dic = create_dummy(db, user_id=user_id, course=c_id)
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes, task_id=id_dic["task_id"], name="task"+str(id_dic["task_id"]), user_id=user_id)
files = db.select_file_details(task_id=id_dic["task_id"])
assert len(files) == 1
assert files[0].name == "task"+str(id_dic["task_id"])
assert files[0].id == id
assert rand_bytes, _ == db.get_file(id)
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,submit_id=id_dic["submit_id"], name="submit_id"+str(id_dic["submit_id"]), user_id=user_id)
sub_id = id_dic["submit_id"]
files = db.select_file_details(submit_id=sub_id)
assert len(files) == 1
assert files[0].name == "submit_id"+str(id_dic["submit_id"])
assert files[0].id == id
assert rand_bytes, _ == db.get_file(id)
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,assignment_id=id_dic["assignment_id"], name="assignment_id"+str(id_dic["task_id"]), user_id=user_id)
files = db.select_file_details(assignment_id=id_dic["assignment_id"])
assert len(files) == 1
assert files[0].name == "assignment_id"+str(id_dic["assignment_id"])
assert files[0].id == id
db_bytes, name = db.get_file(id)
assert rand_bytes == db_bytes
rand_bytes= os.urandom(20)
id = file_insert_helper(db,binary_file=rand_bytes,answer_id=id_dic["answer_id"], name="answer_id"+str(id_dic["task_id"]), user_id=user_id)
files = db.select_file_details(answer_id=id_dic["answer_id"])
assert len(files) == 1
assert files[0].name == "answer_id"+str(id_dic["answer_id"])
assert files[0].id == id
assert rand_bytes, _ == db.get_file(id)
def login_auth():
if request.method == "GET":
app.logger.info(db.engine)
return render_template("auth/login.html",
form=LoginForm(),
next=request.args.get("next"))
form = LoginForm(request.form)
user = db.get_user(form.username.data, form.password.data)
if user is None:
return render_template("auth/login.html",
form=form,
error="No such username or password"), 401
login_user(user)
app.logger.info("User " + form.username.data + " validated")
if request.form.get("next"):
try:
return redirect(request.form.get("next"))
except:
pass
return redirect(url_for("index"))
def test_simple_assignment(db_test_client, a_files=[], t_files=[]):
from application import db
from .course_test import test_course_insert
id, code = test_course_insert(db_test_client)
student = db.get_user("oppilas", "oppilas")
teacher = db.get_user("opettaja", "opettaja")
assert student is not None
assert teacher is not None
db.enlist_student(code, student.id)
visible_a_name = get_random_unicode(30)
reveal = random_datetime()
deadline = random_datetime(start=reveal)
a_id = db.insert_assignment(teacher.id, id, visible_a_name, deadline,
reveal, a_files)
points = random.randint(5, 20)
t_desc = get_random_unicode(30)
t_id = db.insert_task(teacher.id, a_id, t_desc, points, t_files)
with db.engine.connect() as conn:
sql = select([db.assignment]).where(db.assignment.c.id == a_id)
rs = conn.execute(sql)
row = rs.first()
assert row is not None
assert row[db.assignment.c.id] == a_id
assert row[db.assignment.c.name] == visible_a_name
assert pytz.utc.localize(row[db.assignment.c.deadline]) == deadline
assert pytz.utc.localize(row[db.assignment.c.reveal]) == reveal
sql = select([db.task]).where(db.task.c.id == t_id)
rs = conn.execute(sql)
row = rs.first()
assert row is not None
assert row[db.task.c.id] == t_id
assert row[db.task.c.description] == t_desc
assert row[db.task.c.points] == points
assert row[db.task.c.assignment_id] == a_id
null = db.select_assignment(28128218)
assert null is None
a = db.select_assignment(a_id)
assert isinstance(a, Assignment)
assert len(a.tasks) == 1
assert a.id == a_id
assert a.name == visible_a_name
assert a.deadline == deadline
assert a.reveal == reveal
t = a.tasks[0]
assert isinstance(t, Task)
assert t.id == t_id
assert t.description == t_desc
assert t.points == points
assert t.assignment_id == a_id
null = db.select_assignment(a_id, for_student=True)
assert null is None
def test_large_assignment_timezone_helsinki(db_test_client, files=[]):
from application import db
db.insert_user("opettaja1", "opettaja", "Who", "Cares", role="TEACHER")
db.insert_user("opettaja2", "opettaja", "Who", "Cares", role="TEACHER")
db.insert_user("opettaja3", "opettaja", "Who", "Cares", role="TEACHER")
db.insert_user("opettaja4", "opettaja", "Who", "Cares", role="TEACHER")
teacher1 = db.get_user("opettaja1", "opettaja")
teacher2 = db.get_user("opettaja2", "opettaja")
teacher3 = db.get_user("opettaja3", "opettaja")
teacher4 = db.get_user("opettaja4", "opettaja")
teachers = [teacher1, teacher2, teacher3, teacher4]
assert teacher1 is not None
assert teacher2 is not None
assert teacher3 is not None
assert teacher4 is not None
teacher_assigments = []
for teacher in teachers:
all_assignments = {}
visible_assignments = {}
course_ids = insert_random_courses(teacher.id, db)
assert len(course_ids) > 0
for _ in range(random.randint(12, 21)): #insert assignments
name = get_random_unicode(15)
course_id = random.choice(course_ids)
if random.randint(0, 1) or not visible_assignments.get(course_id):
visible = True
reveal = pytz.timezone("Europe/Helsinki").localize(
datetime.datetime.now()) - datetime.timedelta(minutes=1)
else:
visible = False
reveal = pytz.timezone("Europe/Helsinki").localize(
datetime.datetime.now()) + datetime.timedelta(
hours=random.randint(3, 5), minutes=1)
deadline = random_datetime(start=reveal,
time_zone="Europe/Helsinki")
assig_id = db.insert_assignment(teacher1.id, course_id, name,
deadline, reveal, files)
tasks = []
for _ in range(random.randint(2, 15)):
task = random_task(assig_id, files)
task_id = db.insert_task(teacher.id, assig_id,
task.description, task.points, files)
task.id = task_id
tasks.append(task)
result_dict = {
"teacher_id": teacher.id,
"id": assig_id,
"reveal": reveal,
"deadline": deadline,
"course_id": course_id,
"name": name,
"files": files,
"tasks": tasks
}
if not all_assignments.get(course_id):
all_assignments[course_id] = [result_dict]
else:
all_assignments[course_id].append(result_dict)
if visible:
if not visible_assignments.get(course_id):
visible_assignments[course_id] = [result_dict]
else:
visible_assignments[course_id].append(result_dict)
temp = (teacher.id, all_assignments, visible_assignments)
teacher_assigments.append(temp)
for teacher_id, all_assignments, visible_assignments in teacher_assigments:
courses = db.select_courses_teacher(teacher_id)
assert len(courses)
course_ids = [c.id for c in courses]
for key in all_assignments.keys():
assert key in course_ids
for course in courses:
correct_assignments = all_assignments.get(course.id, [])
correct_visible_assignments = visible_assignments.get(course.id)
db.set_assignments(course, for_student=False)
course.set_timezones("Europe/Helsinki")
assert len(course.assignments) == len(
correct_assignments), "wrong number of assignments"
for a in course.assignments:
assert isinstance(a, Assignment)
assignment_dic = get_correct_assignment(
a.id, correct_assignments)
assert assignment_dic, "\n".join(
format_error(a, correct_assignments))
assert assignment_dic["id"] == a.id
assert assignment_dic["teacher_id"] == teacher_id
assert assignment_dic["course_id"] == course.id
assert a.deadline == assignment_dic["deadline"]
assert a.reveal == assignment_dic["reveal"]
case = unittest.TestCase()
case.assertCountEqual(assignment_dic["tasks"], a.tasks)
db.set_assignments(course, for_student=True)
for a in course.assignments:
assert isinstance(a, Assignment)
assignment_dic = get_correct_assignment(
a.id, correct_visible_assignments)
assert assignment_dic, "\n".join(
format_error(a, correct_visible_assignments))
assert assignment_dic["id"] == a.id
assert assignment_dic["teacher_id"] == teacher_id
assert assignment_dic["course_id"] == course.id
assert a.deadline == assignment_dic["deadline"]
assert a.reveal == assignment_dic["reveal"]
case = unittest.TestCase()
case.assertCountEqual(assignment_dic["tasks"], a.tasks)
return teachers
