def user():
user = User(name="John",
email="*****@*****.**",
session_token="token")
db.add(user)
db.commit()
return user
def test_result_incorrect_smaller(client):
login(client)
user = db.query(User).first()
user.secret_number = 10
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 20})
assert b'Your guess is not correct... try something smaller' in response.data
def test_result_correct(client):
login(client)
user = db.query(User).first()
user.secret_number = 10
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 10})
assert b'Correct! The secret number is 10' in response.data
def test_result_correct(client):
client.post('/login', data={"name": "Test User", "email": "*****@*****.**",
"password": "******"}, follow_redirects=True)
user = db.query(User).first()
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/', data={"ugibanje": 22})
assert b'Bravo, zadel si' in response.data
def test_result_incorrect_try_smaller(client):
client.post('/login', data={"name": "Test User", "email": "*****@*****.**",
"password": "******"}, follow_redirects=True)
user = db.query(User).first()
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/', data={"ugibanje": 23})
assert ("Number is too big" in str(response.data))
def test_result_incorrect_try_smaller(client):
# create a user
client.post('/login', data={"user-name": "Test User", "user-email": "*****@*****.**",
"user-password": "******"}, follow_redirects=True)
# get user object from the database
user = db.query(User).first()
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 27}) # enter the wrong guess (too big)
assert b'Your guess is not correct... try something smaller.' in response.data
def test_user_mock_db():
user = Mock()
user.name = "rubenXR"
user.email = "*****@*****.**"
user.password = "******"
user.secret_number = "15"
user.delete = False
user = db.query(User).first()
db.add(user)
db.commit()
def admin_add_user():
if not session.get('loggedin') or session.get('role') != 0:
return redirect(url_for('login'))
form = RegisterForm()
if request.method == 'POST':
if form.validate_on_submit():
username = form.username.data
email = form.email.data
role = form.role.data
password = form.password.data
password_hash = generate_password_hash(password, method='sha256')
sql_query = '''INSERT
INTO
departments
(dept_name,dept_email,password,role) values
(%s,%s,%s,%s)
'''
try:
cursor = db.cursor()
cursor.execute(sql_query,
(username, email, password_hash, role))
cursor.close()
db.commit()
cursor = db.cursor()
cursor.execute(
'SELECT dept_id from departments where dept_name=%s',
(username))
dept_id = cursor.fetchone()
cursor.close()
except Exception as e:
db.rollback()
print("Error while inserting new user", e)
else:
flash(f'Added user {username}.', 'success')
if role == '1':
dept.append([dept_id[0], username, email])
return redirect(url_for('admin_list_users'))
return render_template('admin_add_user.html',
form=form,
logout=url_for('logout'),
back=url_for('admin_list_users'))
def test_result_correct(client):
# create a user
client.post('/login', data={"user-name": "Test User", "user-email": "*****@*****.**",
"user-password": "******"}, follow_redirects=True)
# get the first (and only) user object from the database
user = db.query(User).first()
# set the secret number to 22, so that you can make a success "guess" in the test.
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 22}) # enter the correct guess
assert b'Correct! The secret number is 22' in response.data
def remove_role(login, role):
"""[-login] LOGIN [-role] ROLE_NAME
Remove a role from the user
"""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
user.remove_role(role)
db.commit()
print 'User `%s` no longer has the `%s` role.' % (
login.encode('utf8'), role.encode('utf8'))
def remove_role(login, role):
"""[-login] LOGIN [-role] ROLE_NAME
Remove a role from the user
"""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
user.remove_role(role)
db.commit()
print 'User `%s` no longer has the `%s` role.' % (login.encode('utf8'),
role.encode('utf8'))
def update_user(login, **data):
"""[-login] LOGIN [key=value, ...]
Changes the password of an existing user."""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
for key, val in data.items():
setattr(user, key, val)
db.commit()
print 'User `%s` updated.' % login.encode('utf8')
def update_user(login, **data):
"""[-login] LOGIN [key=value, ...]
Changes the password of an existing user."""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
for key, val in data.items():
setattr(user, key, val)
db.commit()
print 'User `%s` updated.' % login.encode('utf8')
def create_admin():
"""Create the admin user (if it doesn't already exist)"""
from pyceo import prompt
from .manage import create_user
u = User.by_login(u"admin")
if not u:
print "Creating the `admin` user…"
email = prompt(">>> `admin` email?\n")
create_user(u"admin", "admin", fullname=u"Admin", email=email)
u = User.by_login(u"admin")
u.add_role(u"admin")
db.commit()
return u
def add_role(login, role):
"""[-login] LOGIN [-role] ROLE_NAME
Adds a role to the user
"""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
user.add_role(role)
db.commit()
print 'User `%s` has now the `%s` role.' % (
login.encode('utf8'), role.encode('utf8'))
def create_admin():
"""Create the admin user (if it doesn't already exist)"""
from pyceo import prompt
from .manage import create_user
u = User.by_login(u'admin')
if not u:
print 'Creating the `admin` user…'
email = prompt('>>> `admin` email?\n')
create_user(u'admin', 'admin', fullname=u'Admin', email=email)
u = User.by_login(u'admin')
u.add_role(u'admin')
db.commit()
return u
def add_role(login, role):
"""[-login] LOGIN [-role] ROLE_NAME
Adds a role to the user
"""
from main import db
from bundles.users.models import User
user = User.by_login(login)
if not user:
print 'User `%s` not found.' % login.encode('utf8')
return
user.add_role(role)
db.commit()
print 'User `%s` has now the `%s` role.' % (login.encode('utf8'),
role.encode('utf8'))
def test_secret_number_correct(client):
client.post('/login',
data={
"user-name": "ruben",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
user = db.query(User).first()
user.secret_number = 30
db.add(user)
db.commit()
response = client.post('/result', data={"num_user": 30})
assert b'Enhorabuena!! El numero correcto es: 30' in response.data
def test_result_correct(client):
client.post("/login",
data={
"user-name": "Test123",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
user = db.query(User).first()
user.secret_number = 17
db.add(user)
db.commit()
response = client.post("/result", data={"quess": 17})
assert b'Ci' in response.data
def test_result_incorrect_try_smaller(client):
client.post('/login',
data={
"user-name": "Test User",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
user = db.query(User).first()
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 13})
assert b'your guess is not correct... try something smaller.' in response.data
def test_result_try_lower(client):
client.post('/login',
data={
"user-name": "user",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
user = db.query(User).first()
user.secret_number = 2
db.add(user)
db.commit()
response = client.post('/result', data={"quess": 28})
assert b'Twoja liczba jest zbyt mala' in response.data
def test_result_correct(client):
# create a user
client.post('/login',
data={
"user-name": "Test User",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
user = db.query(User).first()
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess":
22}) # enter the correct guess
assert b'Correct! The secret number is 22' in response.data
def test_result_te_klein(client):
# create a user
client.post('/login',
data={
"user-name": "TestUser",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
# get the first (and only) user object from the database
user = db.query(User).first()
# set the secret number to 22, so that you can make a success "guess" in the test.
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess": 20}) # guess is too small
assert b'try something bigger.' in response.data
def delete_user(dept_id):
if not session.get('loggedin') or session.get('role') != 0:
return redirect(url_for('login'))
try:
sql_query = '''DELETE FROM departments WHERE dept_id=%s'''
cursor = db.cursor()
cursor.execute(sql_query, (dept_id, ))
cursor.close()
db.commit()
for ele in dept:
if str(ele[0]) == dept_id:
dept.remove(ele)
except Exception as e:
db.rollback()
print("Error while deleting departments", e)
flash("Deletion unsuccessful", "danger")
return redirect(url_for('admin_list_users'))
def test_result_out_of_bound_high(client):
# create a user
client.post('/login',
data={
"user-name": "TestUser",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
# get the first (and only) user object from the database
user = db.query(User).first()
# set the secret number to 22, so that you can make a success "guess" in the test.
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess":
31}) # guess is out of bound
assert b'Het getal moet tussen 1 en 30 liggen.' in response.data
def test_result_geen_getal(client):
# create a user
client.post('/login',
data={
"user-name": "TestUser",
"user-email": "*****@*****.**",
"user-password": "******"
},
follow_redirects=True)
# get the first (and only) user object from the database
user = db.query(User).first()
# set the secret number to 22, so that you can make a success "guess" in the test.
user.secret_number = 22
db.add(user)
db.commit()
response = client.post('/result', data={"guess":
"Axel"}) # guess is geen getal
assert b'Dat was geen (geheel) getal.' in response.data
def delete_file(file_id):
if not session.get('loggedin') or session.get('role') != 0:
return redirect(url_for('login'))
try:
os.remove(os.getcwd() + '/files/original/' + file_id + '.pdf')
os.remove(os.getcwd() + '/static/files/' + file_id + '.pdf')
os.remove(os.getcwd() + '/static/files/' + file_id + '.tex')
shutil.rmtree(os.getcwd() + '/files/images/' + file_id)
sql_query = '''DELETE FROM transactions WHERE file_id=%s'''
cursor = db.cursor()
cursor.execute(sql_query, (file_id, ))
cursor.close()
db.commit()
flash("Deleted file with File ID " + file_id, "success")
except Exception as e:
db.rollback()
print("Error while deleting transactions", e)
flash("Deletion unsuccessful", "danger")
except:
flash("Deletion unsuccessful", "danger")
return redirect(url_for('admin_file_history'))
DESCR = "List of mountains by elevation"
print("################ DB TESTS ###################")
# Provided DB tests
## No buckets to begin with
assert (len(db.getBuckets()) == 0)
## Adding a bucket
db.addBucket(id=BUCKET_ID, passwordHash=PASSWORD_HASH)
assert (len(db.getBuckets()) == 1)
bucket = db.getBucket(BUCKET_ID)
assert (bucket is not None)
assert (bucket.id == BUCKET_ID)
assert (bucket.passwordHash == PASSWORD_HASH)
assert (db.getBucket(BUCKET_ID + "bah") is None)
assert (db.getBuckets()[0] is bucket)
db.commit()
## Deleting the bucket
db.deleteBucket(bucket)
bucket = db.getBucket(BUCKET_ID)
assert (bucket is None)
db.commit()
## Re-adding the bucket to use in further tests
bucket = db.addBucket(id=BUCKET_ID, passwordHash=PASSWORD_HASH)
## Adding a shortcut
shortcut = db.addShortcut(SHORTCUT_HASH, bucket, LINK, DESCR)
assert (shortcut is not None)
assert (shortcut.linkHash == SHORTCUT_HASH)
assert (shortcut.bucket is bucket)
assert (shortcut.link == LINK)
assert (shortcut.description == DESCR)
assert (len(bucket.shortcuts) == 1)
def admin_modify_user(username):
if not session.get('loggedin') or session.get('role') != 0:
return redirect(url_for('login'))
form = ModifyForm()
if request.method == 'POST':
#insert
email = form.email.data
password = form.password.data
if password != '':
password_hash = generate_password_hash(password, method='sha256')
sql_query = '''UPDATE
departments SET
dept_email = %s, password = %s
where dept_name = %s
'''
try:
cursor = db.cursor()
cursor.execute(sql_query, (
email,
password_hash,
username,
))
cursor.close()
db.commit()
except Exception as e:
db.rollback()
print("Error while modifying user", e)
else:
flash(f'Modified user {username}.', 'success')
else:
sql_query = '''UPDATE
departments SET
dept_email = %s
where dept_name = %s
'''
try:
cursor = db.cursor()
cursor.execute(sql_query, (
email,
username,
))
cursor.close()
db.commit()
except Exception as e:
db.rollback()
print("Error while modifying user", e)
else:
flash(f'Modified user {username}.', 'success')
for dep in dept:
if dep[1] == username:
dep[2] = email
return redirect(url_for('admin_list_users'))
cursor = db.cursor()
cursor.execute(
'SELECT dept_id,dept_name,dept_email FROM departments where dept_name = %s',
(username, ))
departments_data = cursor.fetchone()
cursor.close()
form.username.data = username
form.email.data = departments_data[2]
return render_template('admin_modify_user.html',
form=form,
logout=url_for('logout'),
back=url_for('admin_list_users'))
def delete(self):
self.deleted = True
db.commit()
def restore(self):
self.deleted = False
db.commit()
def restore(self):
self.deleted = False
db.commit()
def delete(self):
self.deleted = True
db.commit()
