def setUp(self):
user_json = open('test/data/user.json')
self.logged_user_json = json.load(user_json)
user_json.close()
self.manage_users = ManageUsers()
self.manage_users.get_user = MagicMock(
return_value=User(self.logged_user_json))
from flask import Blueprint, render_template, request, url_for, session, flash
from werkzeug.utils import redirect
from app.auth.views import login_required
from src.bookshelf.manage_books.manage_books import ManageBooks
from src.bookshelf.manage_reviews.manage_reviews import ManageReviews
from src.bookshelf.manage_users.manage_users import ManageUsers
review = Blueprint('review', __name__, template_folder='templates')
books = ManageBooks()
reviews = ManageReviews()
users = ManageUsers()
@review.route('/add_review/<book_title>', methods=["GET", "POST"])
@login_required
def add(book_title):
book = books.get_by_title(book_title)
if request.method == "POST":
user_id = users.get_user(session['user']).get_id()
reviews.add_new_review(book.get_id(), user_id,
request.form.get("book_rate"),
request.form.get("book_review"))
return redirect(url_for('book.book_page', book_title=book_title))
return render_template('add_review.html', book=book)
@review.route('/remove/<review_id>', methods=["GET", "POST"])
@login_required
def delete(review_id):
delete_review = reviews.delete_review_by_id(review_id)
def setUp(self):
user_json = open('test/data/user.json')
self.user_from_query = json.load(user_json)
user_json.close()
self.manage_user = ManageUsers()
self.manage_user.get_user = MagicMock(return_value=User(self.user_from_query))
class ManageUsersTest(unittest.TestCase):
def setUp(self):
user_json = open('test/data/user.json')
self.user_from_query = json.load(user_json)
user_json.close()
self.manage_user = ManageUsers()
self.manage_user.get_user = MagicMock(return_value=User(self.user_from_query))
def test_login_non_existing_user(self):
"""
Tries to login with non-existent user, Session is None
flash_message = "Invalid Credentials"
"""
login = self.manage_user.login("Joseph", "password")
self.assertIsNone(login["session"])
def test_login_with_existing_user_not_matching_password(self):
"""
Tries to login with user, but wrong password Session is None
flash_message = "Invalid Credentials"
"""
login = self.manage_user.login("Joseph", "password")
self.assertIsNone(login["session"])
def test_login_with_existing_user_matching_password(self):
"""
Tries to login with correct user credentials, Returns valid session
"""
login = self.manage_user.login("willfarnaby", "12345")
self.assertIsNone(login["session"])
# Register
def test_register_with_passwords_not_matching(self):
"""
Tries to register new user with passwords that do not match
"""
register = self.manage_user.register("new_user", "12345", "1234")
self.assertEqual("Passwords do not match", register)
def test_register_with_existing_username(self):
"""
Fail to register with existing User
"""
register = self.manage_user.register("willfarnaby", "12345", "12345")
self.assertEqual("username already in use", register)
def test_register_new_user(self):
"""
Fail to register with user already in DB
"""
self.manage_user.get_user = MagicMock(return_value=None)
self.manage_user.create_user = MagicMock(return_value=None)
register = self.manage_user.register("new_user", "12345", "12345")
self.assertEqual("Registration Successful!", register)
def test_register_new_user_create_returns_Error(self):
"""
Fail to register with user already in DB
"""
self.manage_user.get_user = MagicMock(return_value=None)
self.manage_user.create_user = MagicMock(return_value="Error")
register = self.manage_user.register("new_user", "12345", "12345")
self.assertEqual("There was a problem when trying to create this user, Try Again!", register)
from functools import wraps
from flask import Blueprint, request, flash, redirect, url_for, render_template, session
from src.bookshelf.manage_users.manage_users import ManageUsers
auth = Blueprint('auth', __name__, template_folder='templates')
manage_users = ManageUsers()
@auth.route("/register", methods=["GET", "POST"])
def register():
if request.method == "POST":
register_message = manage_users.register(
request.form.get("username"), request.form.get("password"),
request.form.get("repeat_password"))
flash(register_message)
if register_message == "Registration Successful!":
return redirect(url_for('auth.login'))
else:
return render_template("register.html")
return render_template("register.html")
@auth.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
user_login = manage_users.login(request.form.get("username"),
request.form.get("password"))
flash(user_login["flash_message"])
def __init__(self):
super().__init__()
self.manage_users = ManageUsers()
class ManageReviews(ManageReviewSuper):
"""
manage to handles Book Reviews
"""
def __init__(self):
super().__init__()
self.manage_users = ManageUsers()
def get_rate_by_book_id(self, book_id: str):
"""
Calculates book average rate from all reviews book received
:param book_id:
:return: int() rounded rate average or 0
"""
book_rate = []
book_reviews = self.get_many(book_id, "book_id")
if book_reviews:
for review in book_reviews:
review = review
book_rate.append(review.get_rate())
if len(book_rate) == 0:
return 0
return round(statistics.mean(book_rate))
else:
return 0
def delete_review_by_id(self, review_id: str):
"""
Delete Review by Id, then returns flash message and book_title
:param review_id: str
:return: response: dict
"""
response = {
'flash_message': "Could Not delete review, Try Again",
'book_id': ''
}
review = self.get_by_id(review_id)
book_id = review.get_book_id()
self.delete(review_id)
response['flash_message'] = 'Review deleted successfully.'
response['book_id'] = review.get_book_id()
return response
def add_new_review(self, book: Book, user: User, book_rate: int, book_review: str):
"""
Adds new review from dict with information passed from web form
:param book:
:param user:
:param book_rate:
:param book_review:
:return: response with flash message
"""
response = {
"flash_message": "Review created successfully."
}
review = Review({
'book_id': ObjectId(book),
'rate': book_rate,
'reviewer_id': ObjectId(user),
'feedback': book_review
})
create_review = self.create(review)
if create_review is not None:
response['flash_message'] = "Could Not create review, Try Again"
return response
def get_reviews(self, value: str, field_name: str):
"""
Queries Data Storage for reviews, Supports either book_id or reviewer_id
:param value:
:param field_name: book_id or reviewer_id to specify which is the Id being passed to the query
:return: dict of reviews or None
"""
if field_name == 'reviewer_id' or field_name == 'book_id':
reviews = []
reviews_from_storage = self.get_many(value, field_name)
if reviews_from_storage:
for review in reviews_from_storage:
review.get_reviewer_id()
user_name = self.manage_users.get_by_id(review.get_reviewer_id())
if user_name:
review.set_reviewer_name(user_name.get_first_name())
else:
review.set_reviewer_name("Anonymous")
reviews.append(review)
print(review)
return reviews
else:
raise Exception(f'field_name has to be either reviewer_id or book_id. Received: {field_name}')
return reviews
class UpdateUsersTest(unittest.TestCase):
def setUp(self):
user_json = open('test/data/user.json')
self.logged_user_json = json.load(user_json)
user_json.close()
self.manage_users = ManageUsers()
self.manage_users.get_user = MagicMock(
return_value=User(self.logged_user_json))
def test_first_and_last_update(self):
"""
Test update of first and last name.
Expect to succeed and return success flash message
"""
user = User(self.logged_user_json)
updated_information_from_form = {
'first_name': 'Will',
'last_name': 'Farna'
}
self.manage_users.update_user_information = MagicMock(
return_value=None)
update_details = self.manage_users.update_details(
user, updated_information_from_form)
self.assertEqual(update_details["flash_message"],
"Information Updated successfully")
def test_fail_update_password_unmatching_fields(self):
"""
Test update of password.
Expect to return warning message and never call DB for update information
"""
user = User(self.logged_user_json)
updated_information_from_form = {
'password': '******',
'repeat_password': '******'
}
update_details = self.manage_users.update_details(
user, updated_information_from_form)
self.assertEqual(update_details["flash_message"],
"Password do not match, couldn't update information")
def test_correct_update_password_matching_fields(self):
"""
Test update of password
Expect to succeed and return success flash message
"""
user = User(self.logged_user_json)
updated_information_from_form = {
'password': '******',
'repeat_password': '******'
}
self.manage_users.update_user_information = MagicMock(
return_value=None)
update_details = self.manage_users.update_details(
user, updated_information_from_form)
self.assertEqual(update_details["flash_message"],
"Information Updated successfully")
def test_update_correct_fields_db_error_response(self):
"""
Test update of password
Expect to succeed and return success flash message
"""
user = User(self.logged_user_json)
updated_information_from_form = {
'password': '******',
'repeat_password': '******',
'first_name': 'Will',
'last_name': 'Farna'
}
self.manage_users.update_user_information = MagicMock(
return_value="Error")
update_details = self.manage_users.update_details(
user, updated_information_from_form)
self.assertEqual(
update_details["flash_message"],
"Something went wrong whe trying to update information, Try Again."
)