def setUp(self):
db.create_all()
user = User(
email='*****@*****.**',
username='******',
password='******',
admin=True
)
duplicate_user = User(
email='*****@*****.**',
username='******',
password='******'
)
data = Bathroom(
name='test bathroom',
location='NYC',
open_year_round=True,
handicap_accessible=True,
borough='Manhattan',
latlong="{'lng': -73.9712488, 'lat': 40.7830603}"
)
db.session.add(user)
db.session.add(duplicate_user)
db.session.add(data)
bathroom = Bathroom.query.first()
user = User.query.first()
rating = Rating(
user_id=user.id,
bathroom_id=bathroom.id,
rating=5
)
db.session.add(rating)
db.session.commit()
def test_stat_api(self):
with self.client:
# like adding test
user = User('*****@*****.**', 'nopassword', is_superuser=True)
db.session.add(user)
default_user = User('*****@*****.**', 'diff_pas', False)
db.session.add(default_user)
db.session.flush()
# creating test posts
posts = []
for i in range(3):
posts.append(Post('some text' + str(i), user.id))
db.session.add_all(posts)
db.session.flush()
likes = []
for i in range(3):
likes.append(Likes(user.id, posts[i].id))
db.session.add_all(likes)
db.session.flush()
aut_token = user.encode_auth_token(user.id)
aut_token_non_admin = user.encode_auth_token(default_user.id)
# Test analytics for admin user
response = self.client.get(
'api/analitics/?date_from=2020-01-15&date_to=2020-02-15',
headers=dict(Authorization='Bearer ' +
str(aut_token, 'UTF-8')),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertEqual(response.status_code, 200)
# Test for 3 posts
response = self.client.get(
'api/analitics/?date_from=2020-01-15&date_to=2022-02-15',
headers=dict(Authorization='Bearer ' +
str(aut_token, 'UTF-8')),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertTrue(data['likes_counter'] == len(likes))
self.assertEqual(response.status_code, 200)
# Test analytics for non admin user
response = self.client.get(
'api/analitics/?date_from=2020-01-15&date_to=2020-02-15',
headers=dict(Authorization='Bearer ' +
str(aut_token_non_admin, 'UTF-8')),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 'fail')
self.assertTrue(data['message'] == 'Access denied.')
self.assertEqual(response.status_code, 404)
def setUp(self):
db.create_all()
user = User(email="*****@*****.**", password="******")
db.session.add(user)
db.session.commit()
user = User(email="*****@*****.**", password="******")
db.session.add(user)
db.session.commit()
def post(self):
post_data = request.get_json()
user = User.query.filter_by(email=post_data.get("email")).first()
if not user:
try:
user = User(email=post_data.get("email"), password=post_data.get("password"))
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
response_object = {
"status": "success",
"message": "Successfully registered.",
"auth_token": auth_token,
"user_id": user.id
}
return make_response(jsonify(response_object)), 201
except Exception as e:
print(e)
response_object = {
"status": "fail",
"message": "Some error occured. Please try again."
}
return make_response(jsonify(response_object)), 401
else:
response_object = {
"status": "fail",
"message": "User already exists. Please log in."
}
return make_response(jsonify(response_object)), 202
def test_decode_auth_token(self):
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
decoded = User.decode_auth_token(auth_token)
self.assertEqual(user.id, decoded)
def post(self):
# get the post data
post_data = request.get_json()
# check if user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
try:
user = User(
email=post_data.get('email'),
password=post_data.get('password')
)
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
def register():
form = RegisterForm(request.form)
if form.validate_on_submit():
email = User.query.filter_by(email=form.email.data).first()
username = User.query.filter_by(username=form.username.data).first()
if email is not None:
flash('Email must be unique.', 'danger')
return redirect(url_for('user.register'))
if username is not None:
flash('Username must be unique.', 'danger')
return redirect(url_for('user.register'))
user = User(email=form.email.data,
username=form.username.data,
password=form.password.data)
try:
db.session.add(user)
db.session.commit()
login_user(user)
flash('Thank you for registering.', 'success')
except sqlalchemy.exc.IntegrityError as err:
print('Handle Error:{0}'.format(err))
flash('Something terrible happened.', 'danger')
return redirect(url_for('user.register'))
flash('Thank you for registering.', 'success')
return render_template('user/register.html', form=form)
def test_user_delete(self):
with self.client:
reg_response = self.register_user('*****@*****.**', 'John', 'Doe', 'admin')
self.assertEqual(reg_response.status_code, 201)
self.assertEqual(reg_response.content_type, 'application/json')
data = json.loads(reg_response.data.decode())
self.assertTrue('data' in data)
self.assertTrue('attributes' in data['data'])
self.assertTrue('token' in data['data']['attributes'])
user = User(
email="*****@*****.**",
first_name='Somebody',
last_name='Else',
password='******',
admin=False
)
db.session.add(user)
db.session.commit()
del_response = self.client.delete(
'/'+api_version_prefix+'/users/2',
headers=dict(
Authorization='Bearer ' + json.loads(
reg_response.data.decode()
)['data']['attributes']['token']
)
)
self.assertEqual(del_response.status_code, 200)
def post(self):
# get the post data
post_data = request.get_json()
# check if user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
try:
user = User(email=post_data.get('email'),
password=post_data.get('password'))
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'exito',
'message': 'Registro exitoso',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject))
except Exception as e:
responseObject = {
'status': 'Error',
'message': 'Algo ocurrio, intenta de nuevo'
}
return make_response(jsonify(responseObject))
else:
responseObject = {
'status': 'Error',
'message': 'Usuario ya registrado. Inicie Sesion',
}
return make_response(jsonify(responseObject))
def post(self):
response_msg = []
email = request.json.get('email', None)
password = request.json.get('password', None)
first_name = request.json.get('first_name', None)
last_name = request.json.get('last_name', None)
is_admin = request.json.get('is_admin', None)
if not email:
response_msg.append('email must be non-empty')
if not password:
response_msg.append('password must be non-empty')
if not first_name:
response_msg.append('first_name must be non-empty')
if not last_name:
response_msg.append('last_name must be non-empty')
if is_admin is None:
response_msg.append('is_admin must be non-empty')
if len(response_msg) > 0:
responseObject = {
'status': 'failed',
'message': response_msg
}
return make_response(jsonify(responseObject)), 400
user = User.query.filter_by(email=email).first()
if not user:
try:
user = User(
email=email,
password=password,
first_name=first_name,
last_name=last_name,
is_admin=is_admin
)
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id, int(is_admin))
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
print(e)
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
def post(self):
# get the post data
post_data = request.get_json()
# check if user already exists
username = post_data.get('username')
user = User.find_one_by_username(username)
if not user:
try:
user = User(username=post_data.get('username'),
email=post_data.get('email'),
password=post_data.get('password'))
# insert the user
user.save()
# generate the auth token
auth_token = user.encode_auth_token(user._id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
print(e)
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
def test_post_creation(self):
""" Test for post creation """
with self.client:
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.flush()
aut_token = user.encode_auth_token(user.id)
response = self.client.post(
'/post/create',
headers=dict(Authorization='Bearer ' +
str(aut_token, 'UTF-8')),
data=json.dumps(dict(post_text="Testing post creation")),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertTrue(data['message'] == 'Added new post.')
self.assertTrue(response.content_type == 'application/json')
self.assertEqual(response.status_code, 200)
test_post = Post.query.filter_by(id=1).first()
self.assertTrue(test_post.post_text == "Testing post creation")
self.assertTrue(isinstance(test_post.created_on, dtm))
def home():
form = RegisterForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
try:
# add user to the db
user = User(email=form.email.data)
db.session.add(user)
db.session.commit()
# generate token, confirm url, and template
token = encode_token(user.email)
confirm_url = generate_url('main.confirm_email', token)
body = render_template('email.txt', confirm_url=confirm_url)
# enqueue
redis_url = current_app.config['REDIS_URL']
with Connection(redis.from_url(redis_url)):
q = Queue()
q.enqueue(send_email, user.email, body)
flash('Thank you for registering.', 'success')
return redirect(url_for("main.home"))
except IntegrityError:
db.session.rollback()
flash('Sorry. That email already exists.', 'danger')
users = User.query.all()
return render_template('home.html', form=form, users=users)
def post(self):
# get the post data
post_data = request.get_json()
# check if user already exists
user = User.query.filter_by(email=post_data.get("email")).first()
if not user:
try:
user = User(email=post_data.get("email"),
password=post_data.get("password"))
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
"status": "success",
"message": "Successfully registered.",
"auth_token": auth_token.decode(),
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
responseObject = {
"status": "fail",
"message": "Some error occurred. Please try again.",
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
"status": "fail",
"message": "User already exists. Please Log in.",
}
return make_response(jsonify(responseObject)), 202
def register():
form = RegisterForm(request.form)
if form.validate_on_submit():
user = User(
user_name=form.user_name.data,
email=form.email.data,
password=form.password.data
)
db.session.add(user)
db.session.commit()
db.session.refresh(user)
# create default team
team = Team(name="default", owner=user.id)
db.session.add(team)
db.session.commit()
db.session.refresh(team)
# add self to default team
team_membership = TeamMembership(team_id=team.id, member_id=user.id)
db.session.add(team_membership)
db.session.commit()
login_user(user)
flash('Thank you for registering.', 'success')
return redirect(url_for("user.ideas"))
return render_template('user/register.html', form=form)
def test_decode_auth_token(self):
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(User.decode_auth_token(auth_token) == 1)
def create():
if current_user.is_admin():
form = CreateUserForm(request.form)
form.racer.choices = get_availableRacers('NONE')
if form.validate_on_submit():
user = User(email=form.email.data,
password=form.password.data,
admin=form.admin.data)
if form.racer.data != 0:
racer = db.session.query(Racer).filter_by(
id=form.racer.data).first()
user.racer = racer
db.session.add(user)
db.session.commit()
flash('New user created.', 'success')
return redirect(url_for("admin_user.main", pghead=get_pghead()))
return render_template('admin/user/create.html',
form=form,
pghead=get_pghead())
else:
flash('You are not an admin!', 'danger')
return redirect(url_for("user.members"))
def post(self):
# mengambil data
post_data = request.get_json()
# kemudian check apakah user sudah ada
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
try:
user = User(
email=post_data.get('email'),
password=post_data.get('password')
)
# bila belum maka masukan user baru
db.session.add(user)
db.session.commit()
# bila input berhasil maka akan menampilkan token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
def create_users():
db.session.add(
User(user_name="jkassel",
email="*****@*****.**",
first_name="Jeff",
last_name="Kassel",
location="Staten Island, NY",
website="http://kassellabs.com",
age=36,
password="******",
about_me="Some stuff about me"))
db.session.add(
User(user_name="jsmith",
email="*****@*****.**",
first_name="John",
last_name="Smith",
location="Orlando, FL",
website="http://jsmith.com",
age=36,
password="******",
about_me="Some stuff about me"))
db.session.add(
User(user_name="mjordan",
email="*****@*****.**",
first_name="Michael",
last_name="Jordan",
location="Charlotte, NC",
website="http://michaeljordan.com",
age=56,
password="******",
about_me="I like basketball"))
db.session.add(
User(user_name="mtyson",
email="*****@*****.**",
first_name="Mike",
last_name="Tyson",
location="Brooklyn, NY",
website="http://miketyson.com",
age=56,
password="******",
about_me="I like to hit people"))
db.session.commit()
print("Users created.")
def setUp(self):
BaseTestCase.setUp(self)
self.user = User(
username='******',
password='******'
)
db.session.add(self.user)
db.session.commit()
def test_decode_auth_token(self):
user = User(email="*****@*****.**", password="******")
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def create_admin():
"""Creates the admin user."""
db.session.add(
User(username="******",
email="*****@*****.**",
password="******",
admin=True))
db.session.commit()
def test_decode_auth_token(self):
""" Test for decoding authentication token """
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def test_add_favourite(self):
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
user.add_favourite(tmdb_id=69740)
favourites = user.favourites
favourite = favourites.pop()
self.assertEqual(favourite.user_id, 1)
self.assertEqual(favourite.tmdb_id, 69740)
def addAdmin():
new_admin = User(
email='*****@*****.**',
username='******',
password='******',
admin=True
)
db.session.add(new_admin)
db.session.commit()
def create():
if request.method == 'POST':
user = User(name=request.form['name'],
email=request.form['email'],
password=request.form['password'])
db.session.add(user)
db.session.commit()
return redirect(url_for('user.members'))
return render_template('user/edit.html')
def test_get_show(self):
user = User(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
user.add_favourite(tmdb_id=69740)
favourites = user.favourites
favourite = favourites.pop()
show = favourite.get_show()
self.assertEqual(show.name, 'Ozark')
def test_encode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
screen_name='joeThePlumber')
db.session.add(user)
db.session.commit()
auth_token, exp = user.encode_auth_token(user.id)
print(exp)
self.assertTrue(isinstance(auth_token, bytes))
def create_data():
"""Creates sample data."""
user = User(name="Example User",
email="*****@*****.**",
password="******",
admin=False,
activated=True,
activated_on=datetime.datetime.now())
db.session.add(user)
names = [user.name]
for n in range(99):
fake = Faker()
while len(fake.name()) < 51 and fake.name() in names:
fake = Faker()
name = fake.name()
names.append(name)
email = f"example-{n+1}@railstutorial.org"
password = "******"
db.session.add(
User(name=name,
email=email,
password=password,
admin=False,
activated=True,
activated_on=datetime.datetime.now()))
db.session.commit()
users = User.query.limit(6)
for user in users:
fake = Faker()
content = fake.sentence()
db.session.add(Micropost(content=content, user_id=user.id))
db.session.commit()
users = User.query.all()
user = users[0]
following = users[2:50]
followers = users[3:40]
for followed in following:
user.follow(followed)
for follower in followers:
follower.follow(user)
def create_admin():
"""Creates the admin user."""
db.session.add(
User(name="admin",
email="*****@*****.**",
password="******",
admin=True,
activated=True,
activated_on=datetime.datetime.now()))
db.session.commit()
