def test_gelete_request_teacher(self):
credentials = b64encode(b"student:password")
test=self.client.post("/request", headers={"Authorization": f"Basic {credentials}"},
data={"course_id": 11})
print(test.data)
credentials = b64encode(b"teacher:password")
test = self.client.delete("/request", headers={"Authorization": f"Basic {credentials}"},
data={"id":1})
print(test.data)
self.assertEqual(204, test.status_code)
def test_teacher_course_get_fail(self):
user = User(id=4, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="teacher")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"fail:password")
test = self.client.get("/course", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(404, test.status_code)
def test_delete_wallet_wrong_auth(self):
credentials = b64encode(b"Yurii21:1234")
exist = self.client.delete(
"/wallet/1/delete",
headers={"Authorization": f"Basic {credentials}"})
print(exist.status_code)
assert exist.status_code == 401
def test_user_delete(self):
user = User(id=3, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="student")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"delete:password")
test = self.client.delete("/user", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(204, test.status_code)
def get_api_headers(self, username, password):
return {
'Authorization': 'Basic ' + b64encode(
(username + ':' + password).encode('utf-8')),
'Accept': 'application/json',
'Content-Type': 'application/json'
}
def test_get_wallet_wrong_id(self):
credentials = b64encode(b"Yurii:1234")
test = self.client.get(
"/wallet/100/get_wallet",
headers={"Authorization": f"Basic {credentials}"})
print(test.data)
self.assertEqual(404, test.status_code)
def test_delete(self):
course = Course(id=5, title="title", filling="filling", creator_id=12)
db.session.add(course)
db.session.commit()
credentials = b64encode(b"teacher:password")
test = self.client.delete("/course", headers={"Authorization": f"Basic {credentials}"}, data={"id": 5})
self.assertEqual(204, test.status_code)
def test_user_put(self):
user = User(id=4, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="student")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"username:password")
test = self.client.put("/user", headers={"Authorization": f"Basic {credentials}"}, data={"firstname": "testf", "lastname": "testl", "username": "******", "password": "******"})
print(test.data)
self.assertEqual(200, test.status_code)
def test_put_user(self):
credentials = b64encode(b"Yurii:1234")
exist = self.client.put(
"/user",
headers={"Authorization": f"Basic {credentials}"},
data={"username": "******"})
print(exist.data)
assert exist.status_code == 200
def test_wallet_put(self):
credentials = b64encode(b"Yurii:1234")
test = self.client.put(
"/wallet/1/change",
headers={"Authorization": f"Basic {credentials}"},
data={
"name": "my_wallet2",
})
print(test.data)
self.assertEqual(405, test.status_code)
def test_post_wallet_invalid_input(self):
credentials = b64encode(b"Yurii:1234")
exist = self.client.post(
"/wallet/",
headers={"Authorization": f"Basic {credentials}"},
data={
"user_id": 9,
"name": "Wallet",
"uah": 100,
"owner_uid": 10
})
print(exist.data)
self.assertEqual(405, exist.status_code)
def test_wallet_put_wrong(self):
credentials = b64encode(b"Yurii:1234")
test = self.client.put(
"/wallet/4/change",
headers={"Authorization": f"Basic {credentials}"},
data={
"user_id": 4,
"name": "mywallet2",
"uah": 100,
"owner_uid": 4,
})
print(test.data)
self.assertEqual(404, test.status_code)
def default_user():
user = User(username="******",
firstname="DefaultUser",
lastname="DefaultUser",
email="*****@*****.**",
password_hash=User.hash_password("user"),
phone_number=".!.",
photo="user.png",
role='user')
user.password = '******'
user.credentials = b64encode(b'DefaultUser:user')
user.wrong_credentials = b64encode(b'DefaultUser:user1')
user.headers = {"Authorization": "Basic {}".format(user.credentials)}
user.wrong_credentials_headers = {
"Authorization": "Basic {}".format(user.wrong_credentials)
}
session = db_session()
session.add(user)
session.commit()
return user
def test_user_reservation(client, admin, default_movie, default_user):
"""
1. Creating 2 movie schedules by admin
"""
response = client.post('/schedule',
json={
"date": "04-07-2004",
"time": "14:35:00",
"movie_id": default_movie.id
},
headers=admin.headers)
assert response.status_code == 201
# movie schedule id 1
movie_schedule_id1 = response.get_json()['MovieSchedule']['id']
response = client.post('/schedule',
json={
"date": "04-07-2004",
"time": "18:35:00",
"movie_id": default_movie.id
},
headers=admin.headers)
assert response.status_code == 201
# movie schedule id 2
movie_schedule_id2 = response.get_json()['MovieSchedule']['id']
"""
2. Reserving first movie schedule by user DefUser with Fedora credentials
"""
fedora_credentials = b64encode(b'Fedora:qwerty')
fedora_headers = {"Authorization": "Basic {}".format(fedora_credentials)}
response = client.post('/user/reserve',
json={
"movie_schedule_id": movie_schedule_id1,
"user_id": default_user.id
},
headers=fedora_headers)
assert response.status_code == 406
"""
3. Reserving second movie schedule by defUser user with defUser user
credentials
"""
response = client.post('/user/reserve',
json={
"movie_schedule_id": movie_schedule_id2,
"user_id": default_user.id
},
headers=default_user.headers)
assert response.status_code == 201
def admin():
admin = User(username="******",
firstname="admin",
lastname="admin",
email="*****@*****.**",
password_hash=User.hash_password("admin"),
phone_number=".!.",
photo="photo.jpeg",
role='admin')
admin.password = '******'
admin.credentials = b64encode(b'admin:admin')
admin.wrong_credentials = b64encode(b'admin:admin1')
admin.headers = {"Authorization": "Basic {}".format(admin.credentials)}
admin.wrong_credentials_headers = {
"Authorization": "Basic {}".format(admin.wrong_credentials)
}
session = db_session()
session.add(admin)
session.commit()
return admin
def update(id):
if request.method == "POST":
issue_id = request.form["issue_id"]
project = request.form["project"]
priority = request.form["priority"]
status = request.form["status"]
summary = request.form["summary"]
description = request.form["description"]
assignee = request.form["assignee"]
if "delete" in request.form:
db.session.query(Issue).filter(Issue.issue_id == issue_id).delete()
db.session.commit()
flash("Issue Deleted")
return redirect(url_for("add"))
else:
one_issue = db.session.query(Issue).filter(
Issue.issue_id == issue_id).first()
one_issue.project = project
one_issue.priority = priority
one_issue.status = status
one_issue.summary = summary
one_issue.description = description
one_issue.assignee = assignee
db.session.commit()
flash("Issue Updated")
return redirect(url_for("update", id=issue_id))
else: # coming from find
one_issue = db.session.query(Issue).filter(
Issue.issue_id == id).first()
if (one_issue is None):
flash("Issue Not Found")
return redirect(url_for("find"))
new_image = b64encode(one_issue.attached_image)
one_issue.attached_image = new_image
return render_template('update.html',
title='Update Issue',
issue=one_issue)
def test_get_request_student(self):
credentials = b64encode(b"student:password")
test = self.client.get("/request", headers={"Authorization": f"Basic {credentials}"})
print(test.data)
self.assertEqual(404, test.status_code)
def test_user_get(self):
credentials = b64encode(b"student:password")
test = self.client.get("/user", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(200, test.status_code)
def test_get_all_users_wrong_auth(self):
credentials = b64encode(b"Yuri:1234")
test = self.client.get(
"/user", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(401, test.status_code)
def test_student_course_get_fail(self):
credentials = b64encode(b"student:password")
test = self.client.get("/course", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(404, test.status_code)
def test_teacher_course_get(self):
credentials = b64encode(b"teacher:password")
test = self.client.get("/course", headers={"Authorization": f"Basic {credentials}"})
print(test.data)
self.assertEqual(200, test.status_code)
def test_post(self):
credentials = b64encode(b"teacher:password")
test = self.client.post("/course", headers={"Authorization": f"Basic {credentials}"}, data={"title": "title", "filling": "filling"})
print(test.data)
self.assertEqual(201, test.status_code)
def test_user_auth(client, session, default_user):
"""
1. Create not existing 3 users
"""
response = client.post('/user/register',
json={
"username": "******",
"firstname": "Ivan",
"lastname": "Manchur",
"email": "*****@*****.**",
"password": "******",
"phone_number": "0632804617",
"photo": "my_photo.png"
})
assert response.status_code == 201
assert b"LaVuna" in response.data
assert b"lavuna" not in response.data
response = client.post('/user/register',
json={
"username": "******",
"firstname": "Byanka",
"lastname": "KillWereWolf",
"email": "*****@*****.**",
"password": "******",
"phone_number": "0632804632",
"photo": "my_photo.png"
})
assert response.status_code == 201
assert b"Fedora" in response.data
assert b"qwerty" not in response.data
response = client.post('/user/register',
json={
"username": "******",
"firstname": "Volodya",
"lastname": "Remembersky",
"email": "*****@*****.**",
"password": "******",
"phone_number": "0632804689",
"photo": "my_photo.png"
})
assert response.status_code == 201
assert b"Volodya" in response.data
assert b"password123" not in response.data
"""
2. Create existing user
"""
response = client.post('/user/register',
json={
"username": "******",
"firstname": "Ivan",
"lastname": "Manchur",
"email": "*****@*****.**",
"password": "******",
"phone_number": "0632804617",
"photo": "my_photo.png"
})
assert response.status_code == 409
assert b"Conflict" in response.data
"""
3. Create user with not specified all required info
"""
response = client.post('/user/register',
json={
"firstname": "Ivan",
"lastname": "Manchur",
"email": "*****@*****.**",
"password": "******",
"phone_number": "0632804617",
"photo": "my_photo.png"
})
assert response.status_code == 400
assert b"Bad Request" in response.data
"""
4. login existing user with username and password
"""
response = client.get('/user/login',
json={
"username": "******",
"password": "******",
})
assert response.status_code == 200
assert b"Success" in response.data
"""
5. login existing user with email and password
"""
response = client.get('/user/login',
json={
"email": default_user.email,
"password": default_user.password
})
assert response.status_code == 200
assert b"Success" in response.data
"""
6. login user without redundant data
"""
response = client.get('/user/login', json={
"email": "*****@*****.**",
})
assert response.status_code == 406
assert b"Not Acceptable" in response.data
"""
7. login user with wrong email
"""
response = client.get('/user/login',
json={
"email": "[email protected]",
"password": "******"
})
assert response.status_code == 404
assert b"Not Found" in response.data
"""
8. Logout user
"""
response = client.get('user/logout', headers=default_user.headers)
assert response.status_code == 200
"""
9. Update user with invalid credentials
"""
response = client.put('user/%s' % default_user.id,
json={
"lastname": "Gourge",
"firstname": "De Mouchhi"
},
headers=default_user.wrong_credentials_headers)
assert response.status_code == 401
"""
10. Update user with valid credentials
"""
response = client.put('user/%s' % default_user.id,
json={
"lastname": "Gourge",
"firstname": "De Mouchhi"
},
headers=default_user.headers)
assert response.status_code == 200
assert b"Gourge" in response.data
assert b"De Mouchhi" in response.data
"""
11. GET user with invalid credentials
"""
response = client.get("/user/%s" % default_user.id,
headers=default_user.wrong_credentials_headers)
assert response.status_code == 401
"""
12. GET user with valid credentials
"""
response = client.get("/user/%s" % default_user.id,
headers=default_user.headers)
assert response.status_code == 200
assert b"DefaultUser" in response.data
assert b"*****@*****.**" in response.data
"""
13. DELETE default user with token of second user
"""
credentials = b64encode(b'Fedora:qwerty')
headers = {"Authorization": "Basic {}".format(credentials)}
token2 = bytes(
client.get("/token", headers=headers).get_json()["token"] + ":JO",
'utf-8')
credentials = b64encode(token2)
headers = {"Authorization": "Basic {}".format(credentials)}
response = client.delete("/user/%s" % default_user.id, headers=headers)
assert response.status_code == 403
"""
14. DELETE third user with valid credentials (token)
"""
credentials = b64encode(b'Volodya:password123')
headers = {"Authorization": "Basic {}".format(credentials)}
token = bytes(
client.get("/token", headers=headers).get_json()["token"] + ":JO",
'utf-8')
user_id = session.query(User).filter_by(username="******").first().id
credentials = b64encode(token)
headers = {"Authorization": "Basic {}".format(credentials)}
response = client.delete("/user/%s" % user_id, headers=headers)
assert response.status_code == 200
def test_user_delete(self):
credentials = b64encode(b"Yurii:1234")
test = self.client.delete(
"/user", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(204, test.status_code)
def test_delete_user_wrong_req(self):
credentials = b64encode(b"Yurii:1234")
exist = self.client.delete(
"/user/", headers={"Authorization": f"Basic {credentials}"})
assert exist.status_code == 404
def test_get_user_by_id_wrong_auth(self):
credentials = b64encode(b"Yuri:1234")
exist = self.client.get(
"/user/1", headers={"Authorization": f"Basic {credentials}"})
assert exist.status_code == 401
