def setUp(self) -> None:
with app.app_context():
# user for login
example = User()
example.firstname = 'Admin'
example.lastname = 'Admin'
example.email = '*****@*****.**'
example.dateofbirth = datetime.datetime(2020, 10, 5)
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
# reacted story
test_story = Story()
test_story.text = "Test story from admin user"
test_story.author_id = 1
test_story.is_draft = 0
test_story.figures = "#Test#admin#"
db.session.add(test_story)
db.session.commit()
# login
payload = {'email': '*****@*****.**', 'password': '******'}
form = LoginForm(data=payload)
self.client.post('/users/login',
data=form.data,
follow_redirects=True)
def test_runs1(db_instance):
email = 'mock' + str(random.randint(1, 101)) + '@mock.com'
password = '******'
example = User()
example.email = email
example.set_password(password)
runs_id = ['1', '2', '3', '4', '5', '6', '7']
db_instance.session.add(example)
for i in runs_id:
run = Run()
run.runner = example
run.strava_id = i
db_instance.session.add(run)
db_instance.session.commit()
user_id = example.get_id()
previous_run = db_instance.session.query(Run).filter(
Run.runner_id == example.get_id(),
Run.id < 7).order_by(Run.id.desc()).first()
assert previous_run.id == 6
q = db_instance.session.query(Run).filter(
Run.runner_id == example.get_id(), Run.id == 4)
q.delete(synchronize_session=False)
db_instance.session.commit()
previous_run = db_instance.session.query(Run).filter(
Run.runner_id == example.get_id(),
Run.id < 5).order_by(Run.id.desc()).first()
assert previous_run.id == 3
_delete_user(example)
def create_user():
form = UserForm()
if request.method == 'POST':
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
new_user.set_password(form.data['password'])
db.session.add(new_user)
db.session.commit()
return redirect('/users')
return render_template('create_user.html', form=form)
def create_user(new_user: User, password, role_id: int = 3):
"""
:return:
"""
## By default I assume CUSTOMER
new_user.role_id = role_id
new_user.set_password(password)
db.session.add(new_user)
db.session.commit()
q = db.session.query(User).filter(User.email == new_user.email)
user = q.first()
return user
def create_user():
form = UserForm()
if request.method == 'POST':
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
new_user.set_password(
form.password.data) #pw should be hashed with some salt
db.session.add(new_user)
db.session.commit()
return redirect(url_for('home.index'))
return render_template('create_user.html', form=form)
def signup():
form = UserForm()
if request.method == 'POST':
email = form.data['email']
q = db.session.query(User).filter(User.email == email)
check = q.first()
if check is None:
user = User()
user.firstname = form.data['firstname']
user.lastname = form.data['lastname']
user.email = form.data['email']
user.dateofbirth = form.data['dateofbirth']
user.set_password(form.data['password'])
db.session.add(user)
db.session.commit()
login_user(user)
return redirect("/")
else:
form = UserForm()
return render_template(
'signup.html',
form=form,
error=True,
message="The email was used before. Please change the email!")
if request.method == 'GET':
return render_template('signup.html', form=form)
def populate_user():
new_user = User()
new_user.email = "*****@*****.**"
new_user.phone = '3333333333'
new_user.firstname = "firstname_test"
new_user.lastname = "lastname_test"
new_user.password = "******"
new_user.dateofbirth = datetime.date(2020, 10, 5)
new_user.role = "customer"
return new_user
def setUp(self) -> None:
with app.app_context():
# create an user Admin
example = User()
example.firstname = 'Admin'
example.lastname = 'Admin'
example.email = '*****@*****.**'
example.dateofbirth = datetime.datetime(2010, 10, 5)
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
def test_delete_user_with_email(self):
"""
This test cases test if the user service are able to
remove correctly the user inside the DB
Test flow
- Create a new user with the service
- delete a new user with service with user pass
- check on db if this user is gone
"""
form = UserForm()
form.firstname.data = "Vincenzo"
form.lastname.data = "Palazzo"
form.password = "******"
form.phone.data = "12345"
form.dateofbirth = "12/12/2020"
form.email.data = "*****@*****.**"
user = User()
form.populate_obj(user)
user = UserService.create_user(user, form.password, 2)
assert user is not None
assert user.role_id is 2
UserService.delete_user(email=user.email)
user = db.session.query(User).filter_by(email=user.email).first()
assert user is None
def test_modify_user_role_id(self, client):
"""
With this code is tested the services to perform the user modification
with service and have the result on db
Test flow
- Create user
- Modify user
- check user
- delete user to clean the database
"""
form = UserForm()
form.firstname.data = "Vincenzo"
form.lastname.data = "Palazzo"
form.password = "******"
form.phone.data = "12345"
form.dateofbirth = "12/12/2020"
form.email.data = "*****@*****.**"
user = User()
form.populate_obj(user)
user = UserService.create_user(user, form.password, 2)
assert user is not None
assert user.role_id is 2
response = login(client, form.email.data, form.password)
assert response.status_code == 200
assert "logged_test" in response.data.decode("utf-8")
formTest = UserForm(obj=user)
user_modified = UserService.modify_user(formTest, 3)
assert user is not None
assert user.role_id is not 2
UserService.delete_user(user_modified.id)
user_modified = get_user_with_email(user_modified.email)
assert user_modified is None
def signup():
'''
GET
---
Opens the signup page.
Returns:
200 -> the page has been returned
POST
----
Registers a user.
Raises:
IntegrityError -> there is already a user with the chosen username or e-mail address
Returns:
409 -> the exception above has been raised
302 -> the registration was succesful and the user is redirected to its homepage
'''
form = UserForm()
status = 200
if current_user.is_authenticated:
return redirect('/')
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
new_user.set_password(form.password.data)
db.session.add(new_user)
try:
db.session.commit()
login_user(new_user)
return redirect('/')
except IntegrityError as e:
db.session.rollback()
status = 409
if 'user.username' in str(e):
err = 'This username already exists.'
elif 'user.email' in str(e):
err = 'This email is already used.'
form.email.errors.append(err)
return render_template('signup.html', form=form), status
def add_user(email, phone, firstname, lastname, password, date, role):
new_user = User()
new_user.email = email
new_user.phone = phone
new_user.firstname = firstname
new_user.lastname = lastname
new_user.password = password
new_user.role = role
new_user.dateofbirth = date
db.session.add(new_user)
db.session.commit()
return db.session.query(User).filter(User.email == email).first()
def create_user():
if not current_user.is_anonymous:
return redirect("/", code=302)
form = UserForm()
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
new_user.set_password(form.password.data)
db.session.add(new_user)
try:
db.session.commit()
return login()
except IntegrityError:
db.session.rollback()
form.message = "Seems like this email is already used"
return render_template('create_user.html', form=form, notlogged=True)
def test_runs2(db_instance):
email = 'mock' + str(random.randint(1, 101)) + '@mock.com'
password = '******'
example = User()
example.email = email
example.set_password(password)
runs_id = ['1', '2', '3', '4', '5', '6', '7']
db_instance.session.add(example)
for i in runs_id:
run = Run()
run.runner = example
run.strava_id = i
db_instance.session.add(run)
db_instance.session.commit()
user_id = example.get_id()
runId = 150
run = db_instance.session.query(Run).filter(
Run.runner_id == example.get_id(), Run.id == runId).first()
assert run == None
_delete_user(example)
def create_user():
if current_user is not None and hasattr(current_user, 'id'):
return make_response(
render_template(
'error.html',
message="You are already logged! Redirecting to home page",
redirect_url="/"), 403)
form = UserForm()
if request.method == 'POST':
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
new_user.role = request.form['role']
check_already_register = db.session.query(User).filter(
User.email == new_user.email).first()
if (check_already_register is not None):
# already registered
return render_template('create_user.html', form=form), 403
new_user.set_password(
form.password.data) #pw should be hashed with some salt
if new_user.role != 'customer' and new_user.role != 'owner':
return make_response(
render_template(
'error.html',
message=
"You can sign in only as customer or owner! Redirecting to home page",
redirect_url="/"), 403)
db.session.add(new_user)
db.session.commit()
return redirect('/')
else:
# invalid form
return make_response(
render_template('create_user.html', form=form), 400)
return render_template('create_user.html', form=form)
def _create_generic_user(role_id: int = 3, name_on_page: str = "customer"):
"""
This method contains the logic to create a new user with a different role
:param role_id: role id on database this mean that is possible
:param name_on_page: name to customize the page inside the template
:return: response template
"""
form = UserForm()
if request.method == "POST":
if form.validate_on_submit():
q_user_email = UserService.user_is_present(email=form.email.data)
q_user_phone = UserService.user_is_present(phone=form.phone.data)
current_app.logger.error(
"user with email is null? ".format(q_user_email is None)
)
current_app.logger.error(
"user with phone is null? ".format(q_user_phone is None)
)
if (q_user_email is not None) or (q_user_phone is not None):
return render_template(
"create_user.html",
form=form,
message="Email {} and/or number {} already registered".format(
form.email.data, form.phone.data
),
type=name_on_page,
)
user = User()
form.populate_obj(user)
user = UserService.create_user(user, form.password.data, role_id)
if user is not None and user.authenticate(form.password.data):
login_user(user)
DispatcherMessage.send_message(
REGISTRATION_EMAIL,
[user.email, user.lastname, "112344"],
)
new_role = UserService.get_user_role(role_id)
if new_role is not None:
session["ROLE"] = new_role.value
return redirect("/")
return render_template("create_user.html", form=form, type=name_on_page)
def client():
""" This function initialize a new DB for every test and creates the app. This function returns a tuple,
the first element is a test client and the second is the app itself. Test client must be used for sending
request and the app should be used for getting a context when, for example, we need to query the DB.
I haven't found a more elegant way to do this."""
app = create_app()
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db_fd, app.config['DATABASE'] = tempfile.mkstemp()
print(app.config['DATABASE'])
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE']
app.config['TESTING'] = True
app.config[
'WTF_CSRF_ENABLED'] = False # disable CSRF validation -> DO THIS ONLY DURING TESTS!
client = app.test_client()
db.create_all(app=app)
db.init_app(app=app)
#with app.app_context():
#db.engine.execute(_data_sql)
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
example = User()
example.email = '*****@*****.**'
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
yield client, app
os.close(db_fd)
os.unlink(app.config['DATABASE'])
def create_app():
app = Flask(__name__)
app.config['WTF_CSRF_SECRET_KEY'] = 'A SECRET KEY'
app.config['SECRET_KEY'] = 'ANOTHER ONE'
app.config['GITLAB_URI'] = 'https://umcs.schneiderp.ovh'
#app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/gitlab_monolith'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///gitlab-monolith'
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a user
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
suser = User()
suser.email = '*****@*****.**'
suser.is_admin = True
suser.set_password('ok')
db.session.add(suser)
db.session.commit()
return app
def create_app():
app = Flask(__name__)
app.config[
'WTF_CSRF_SECRET_KEY'] = 'ec35ae128aa97f834ab848ecf823340875ddf483e9a535440cf68e05b3b38865'
app.config[
'SECRET_KEY'] = '58c8f1ffb80e7d48d936cb8a485504498fc6c5dcfce18e3de6dcd3b851ff0540'
app.config['STRAVA_CLIENT_ID'] = os.environ['STRAVA_CLIENT_ID']
app.config['STRAVA_CLIENT_SECRET'] = os.environ['STRAVA_CLIENT_SECRET']
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///beepbeep.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a first admin user
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
example = User()
example.email = '*****@*****.**'
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
return app
def create_app():
app = Flask(__name__)
app.config['WTF_CSRF_SECRET_KEY'] = 'A SECRET KEY'
app.config['SECRET_KEY'] = 'ANOTHER ONE'
app.config['STRAVA_CLIENT_ID'] = os.environ['STRAVA_CLIENT_ID']
app.config['STRAVA_CLIENT_SECRET'] = os.environ['STRAVA_CLIENT_SECRET']
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///beepbeep.db'
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a first admin user
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
example = User()
example.email = '*****@*****.**'
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
return app
def create_app():
app = Flask(__name__)
app.config['WTF_CSRF_SECRET_KEY'] = 'A SECRET KEY'
app.config['SECRET_KEY'] = 'ANOTHER ONE'
app.config['STRAVA_CLIENT_ID'] = '31670'
app.config[
'STRAVA_CLIENT_SECRET'] = '47874ae3e3f326817f0c8391d181c67cef645482'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/runnerly'
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a user
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
tarek = User()
tarek.email = '*****@*****.**'
tarek.is_admin = True
tarek.set_password('ok')
db.session.add(tarek)
db.session.commit()
return app
def setUp(self) -> None:
print("SET UP")
with app.app_context():
example = User()
example.firstname = 'Admin'
example.lastname = 'Admin'
example.email = '*****@*****.**'
example.dateofbirth = datetime.datetime(2020, 10, 5)
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
payload = {'email': '*****@*****.**', 'password': '******'}
form = LoginForm(data=payload)
self.client.post('/users/login', data=form.data, follow_redirects=True)
def _create_user():
form = UserForm()
if request.method == 'POST':
if form.validate_on_submit():
# check if the email already exists
email = form.data['email']
user = db.session.query(User).filter(User.email == email).first()
if user is None:
# check if date of birth < today
dateofbirth = form.data['dateofbirth']
if dateofbirth < date.today():
new_user = User()
form.populate_obj(new_user)
new_user.set_password(form.password.data) # pw should be hashed with some salt
db.session.add(new_user)
db.session.commit()
return redirect('/users')
else:
flash("Wrong date of birth.", 'error')
else:
flash("The email address is already being used.", 'error')
return render_template('create_user.html', form=form, home_url=HOME_URL)
def test_die_init(self):
example = User()
example.id = random.randint(0, 2048)
example.firstname = 'userwall'
example.lastname = 'theWall'
example.email = '*****@*****.**'
example.dateofbirth = datetime.datetime(2020, 10, 5)
example.is_admin = True
example.set_password('daddysflownacrosstheocean')
some_stories = [
'story1', 'story2', 'story3', 'story4', 'story5', 'story6'
]
wall = Wall(example)
for s in some_stories:
story = Story()
story.id = random.randint(0, 2048)
story.text = s
story.likes = 0
story.dislikes = 0
wall.add_story(story)
wall.storyLimit = len(wall.stories)
story = Story()
story.id = random.randint(0, 2048)
story.text = 'an extra story'
story.likes = 0
story.dislikes = 0
wall.add_story(story)
wall.add_story(story)
self.assertEqual(len(wall.stories), wall.storyLimit)
def create_user():
# A connected user cannot create other users
if hasattr(current_user, 'is_authenticated') and current_user.is_authenticated is True:
return abort(403)
form = UserForm()
if request.method == 'POST':
if form.validate_on_submit():
new_user = User()
form.populate_obj(new_user)
c = db.session.query(User).filter(new_user.email == User.email)
if c.first() is None:
new_user.set_password(form.password.data) # pw should be hashed with some salt
db.session.add(new_user)
db.session.commit()
return redirect(url_for('auth.login'))
else:
flash('Already existing user', category='error')
return make_response(render_template('create_user.html', form=form), 409)
else:
abort(400)
return render_template('create_user.html', form=form)
def setUp(self) -> None:
with app.app_context():
# user for login
example = User()
example.firstname = 'Admin'
example.lastname = 'Admin'
example.email = '*****@*****.**'
example.dateofbirth = datetime.datetime(2020, 10, 5)
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
# reacted story
test_story = Story()
test_story.text = "Test story from admin user"
test_story.author_id = 1
test_story.is_draft = 0
test_story.figures = "#admin#cat#"
db.session.add(test_story)
db.session.commit()
def test_email_sender(self):
global _app
if _app is None:
tested_app = create_app(debug=True)
_app = tested_app
else:
tested_app = _app
restart_db_tables(db, tested_app)
with tested_app.test_client() as client:
with client.session_transaction() as session:
example2 = User()
example2.firstname = 'Daniele'
example2.lastname = 'Arioli'
example2.email = '*****@*****.**'
example2.dateofbirth = datetime(2020, 10, 5)
example2.is_admin = True
example2.set_password('admin')
db.session.add(example2)
db.session.commit()
self.assertTrue(send_emails())
def test_create_user(self):
"""
test create user
:return:
"""
form = UserForm()
form.firstname.data = "Vincenzo"
form.lastname.data = "Palazzo"
form.password = "******"
form.phone.data = "12345"
form.dateofbirth = "12/12/2020"
form.email.data = "*****@*****.**"
user = User()
form.populate_obj(user)
user = UserService.create_user(user, form.password)
assert user is not None
assert user.role_id is 3
db.session.query(User).filter_by(id=user.id).delete()
db.session.commit()
def create_app():
app = Flask(__name__)
# App
app.config[
'SQLALCHEMY_TRACK_MODIFICATIONS'] = False # suppress pytest warning
app.config['WTF_CSRF_SECRET_KEY'] = 'A SECRET KEY'
app.config['SECRET_KEY'] = 'ANOTHER ONE'
app.config['STRAVA_CLIENT_ID'] = os.environ['STRAVA_CLIENT_ID']
app.config['STRAVA_CLIENT_SECRET'] = os.environ['STRAVA_CLIENT_SECRET']
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///beepbeep.db'
# Mail
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = os.environ['MAIL_USERNAME']
app.config['MAIL_PASSWORD'] = os.environ['MAIL_PASSWORD']
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
from monolith.database import db, User, Report
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a first admin user
with app.app_context():
app.register_error_handler(401, render_error_page)
app.register_error_handler(403, render_error_page)
app.register_error_handler(404, render_error_page)
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
example = User()
example.email = '*****@*****.**'
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
return app
def create_app():
app = Flask(__name__)
app.config['WTF_CSRF_SECRET_KEY'] = 'A SECRET KEY'
app.config['SECRET_KEY'] = 'ANOTHER ONE'
# app.config['STRAVA_CLIENT_ID'] = 29641
# app.config['STRAVA_CLIENT_SECRET'] = "097321492b94a769fe8be68a50ab2a780f30b6dc"
app.config['STRAVA_CLIENT_ID'] = os.environ['STRAVA_CLIENT_ID']
app.config['STRAVA_CLIENT_SECRET'] = os.environ['STRAVA_CLIENT_SECRET']
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///beepbeep.db'
app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = os.environ['EMAIL_ID']
app.config['MAIL_PASSWORD'] = os.environ['EMAIL_PASS']
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
for bp in blueprints:
app.register_blueprint(bp)
bp.app = app
db.init_app(app)
login_manager.init_app(app)
db.create_all(app=app)
# create a first admin user
with app.app_context():
q = db.session.query(User).filter(User.email == '*****@*****.**')
user = q.first()
if user is None:
example = User()
example.email = '*****@*****.**'
example.is_admin = True
example.set_password('admin')
db.session.add(example)
db.session.commit()
return app
