def existing_module(module, name):
modules = { 'user': User, 'diary': Diary }
if db.session.query(
db.exists().where(modules[module].name == name)
).scalar():
return True
return False
def test_delete_entry(self):
"""Test deleting diary twice
"""
new_diary = self.register_diary()
diary_id = json.loads(new_diary.get_data(as_text=True))['diary']['id']
new_entry = self.app.post(
'/api/v2/diaries/{}/entries'.format(diary_id),
data=json.dumps(self.new_entry),
headers={
"content-type": "application/json",
"x-access-token": self.token()
})
entry_id = json.loads(new_entry.get_data(as_text=True))['entry']['id']
self.app.delete('/api/v2/diaries/{}/entries/{}'.format(
diary_id, entry_id),
data=json.dumps(self.new_entry),
headers={
"content-type": "application/json",
"x-access-token": self.token()
})
exists = db.session.query(
db.exists().where(Entry.title == self.new_entry['title']))
self.assertTrue(exists)
def test_delete_review(self):
"""Test deleting business twice
"""
new_business = self.register_business()
business_id = json.loads(
new_business.get_data(as_text=True))['business']['id']
new_review = self.app.post(
'/api/v2/businesses/{}/reviews'.format(business_id),
data=json.dumps(self.new_review),
headers={
"content-type": "application/json",
"x-access-token": self.token()
})
review_id = json.loads(
new_review.get_data(as_text=True))['review']['id']
self.app.delete('/api/v2/businesses/{}/reviews/{}'.format(
business_id, review_id),
data=json.dumps(self.new_review),
headers={
"content-type": "application/json",
"x-access-token": self.token()
})
exists = db.session.query(
db.exists().where(Review.title == self.new_review['title']))
self.assertTrue(exists)
def test_user_registration(self):
"""Test user can be registered
"""
response = self.register()
exists = db.session.query(db.exists().where(
User.username == self.new_user_info['username'])).scalar()
self.assertEqual(response.status_code, 200)
self.assertTrue(exists)
def test_create_business(self):
"""Test if can register new business
"""
response = self.register_business()
self.assertEqual(response.status_code, 201)
output = json.loads(response.get_data(as_text=True))
self.assertEqual(output['success'], 'successfully created business')
exists = db.session.query(db.exists().where(
Business.name == output['business']['name'])).scalar()
self.assertTrue(exists)
def test_create_entry(self):
"""Create new entry for a diary
"""
response = self.register_entry()
self.assertEqual(response.status_code, 201)
self.assertIn('successfully created entry', str(response.data))
_entry = json.loads(response.get_data(as_text=True))
exists = db.session.query(
db.exists().where(Entry.title == _entry['entry']['title']))
self.assertTrue(exists)
def test_create_review(self):
"""Create new review for a business
"""
response = self.register_review()
self.assertEqual(response.status_code, 201)
self.assertIn('successfully created review', str(response.data))
_review = json.loads(response.get_data(as_text=True))
exists = db.session.query(
db.exists().where(Review.title == _review['review']['title']))
self.assertTrue(exists)
def test_login(self):
"""Test Login user"""
new_user = self.register()
exists = db.session.query(db.exists().where(
User.username == self.new_user_info['username'])).scalar()
self.assertEqual(new_user.status_code, 200)
self.assertTrue(exists)
new_login = self.login()
self.assertEqual(new_login.status_code, 200)
self.assertIn('Login success', str(new_login.data))
def wrap(*args, **kwargs):
data = request.get_json()
# check if all fields are provided
if check_keys(data, 4):
return jsonify({
'warning': 'All Fields Required'
}), 400
# check if username is taken
if db.session.query(
db.exists().where(User.username == data['username'])
).scalar():
return jsonify({'warning': 'Username has already been taken'}), 409
# check if email is taken
if db.session.query(
db.exists().where(User.email == data['email'])
).scalar():
return jsonify({'warning': 'Email has already been taken'}), 409
# validate username
if not username_regex.match(data['username'].lower()):
return jsonify({
'warning': 'Invalid username'
}), 409
# validate email
if not email_regex.match(data['email']):
return jsonify({
'warning': 'Invalid email'
}), 409
# validate password
if not password_regex.match(data['password']):
return jsonify({
'warning': 'Provide strong password'
}), 409
return f(*args, **kwargs)
def delete_review(current_user, businessId, reviewId):
"""Delete a Review given a review ID and business ID
confirms if current_user is owner of review
"""
title = ''
review = Review.query.get(reviewId)
if review:
title = review.title
review.delete()
if not db.session.query(db.exists().where(Review.title == title)).scalar():
return jsonify({'success': 'Review Deleted'}), 200
return jsonify({'warning': 'Review Not Deleted'}), 400
def delete_entry(current_user, diaryId, entryId):
"""Delete a Entry given a entry ID and diary ID
confirms if current_user is owner of entry
"""
title = ''
entry = Entry.query.get(entryId)
if entry:
title = entry.title
entry.delete()
if not db.session.query(db.exists().where(Entry.title == title)).scalar():
return jsonify({'success': 'Entry Deleted'}), 200
return jsonify({'warning': 'Entry Not Deleted'}), 400
def test_update_business(self):
"""Test if user can update business
"""
new_business = self.register_business()
business_id = json.loads(
new_business.get_data(as_text=True))['business']['id']
response = self.app.put('/api/v2/businesses/{}'.format(business_id),
data=json.dumps(self.update_business_info),
headers={
"content-type": "application/json",
"x-access-token": self.token()
})
self.assertIn('successfully updated', str(response.data))
_business = json.loads(response.get_data(as_text=True))
exists = db.session.query(
db.exists().where(Business.name == _business['business']['name']))
self.assertTrue(exists)
def test_update_diary(self):
"""Test if user can update diary
"""
new_diary = self.register_diary()
diary_id = json.loads(
new_diary.get_data(as_text=True))['diary']['id']
response = self.app.put(
'/api/v2/diaries/{}'.format(diary_id),
data=json.dumps(self.update_diary_info),
headers={
"content-type": "application/json",
"x-access-token": self.token()
}
)
self.assertIn('successfully updated', str(response.data))
_diary = json.loads(response.get_data(as_text=True))
exists = db.session.query(
db.exists().where(Diary.name == _diary['diary']['name']))
self.assertTrue(exists)
def check_email(email):
if db.session.query(db.exists().where(User.email == email)).scalar():
return True
return False
def test_unsuccesfull_user_registration(self):
"""Test when user is no registered successfully
1. test fail when all fields are not provided
2. test fail when username is taken
3. test fail when email is taken
4. test fail on username validation
5. test fail on email validation
6. test fail on password validation
"""
self.register()
# 1. test fail when all fields are not provided
auth1 = {'username': '******', 'password': '******'}
response1 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth1),
content_type='application/json')
exists1 = db.session.query(
db.exists().where(User.username == auth1['username'])).scalar()
self.assertEqual(response1.status_code, 400)
self.assertFalse(exists1)
self.assertIn('All Fields Required', str(response1.data))
# 2. test fail when username is taken
auth2 = {
'username': '******',
'fullname': 'daniel kamar',
'email': '*****@*****.**',
'password': '******'
}
response2 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth2),
content_type='application/json')
exists2 = db.session.query(
db.exists().where(User.email == auth2['email'])).scalar()
self.assertEqual(response2.status_code, 409)
self.assertFalse(exists2)
self.assertIn('Username has already been taken', str(response2.data))
# 3. test fail when email is taken
auth3 = {
'username': '******',
'fullname': 'vitor muts',
'email': '*****@*****.**',
'password': '******'
}
response3 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth3),
content_type='application/json')
exists3 = db.session.query(
db.exists().where(User.username == auth3['username'])).scalar()
self.assertEqual(response3.status_code, 409)
self.assertFalse(exists3)
self.assertIn('Email has already been taken', str(response3.data))
# 4. test fail on username validation
auth4 = {
'username': '******',
'fullname': 'daniel kamar',
'email': '*****@*****.**',
'password': '******'
}
response4 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth4),
content_type='application/json')
exists4 = db.session.query(
db.exists().where(User.username == auth4['username'])).scalar()
self.assertEqual(response4.status_code, 409)
self.assertFalse(exists4)
self.assertIn('Invalid username', str(response4.data))
# 5. test fail on email validation
auth5 = {
'username': '******',
'fullname': 'daniel kamar',
'email': 'daniel.kamar@',
'password': '******'
}
response5 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth5),
content_type='application/json')
exists5 = db.session.query(
db.exists().where(User.username == auth5['username'])).scalar()
self.assertEqual(response5.status_code, 409)
self.assertFalse(exists5)
self.assertIn('Invalid email', str(response5.data))
# 6. test fail on password validation
auth6 = {
'username': '******',
'fullname': 'daniel kamar',
'email': '*****@*****.**',
'password': '******'
}
response6 = self.app_client.post('/api/v2/auth/register',
data=json.dumps(auth6),
content_type='application/json')
exists6 = db.session.query(
db.exists().where(User.username == auth6['username'])).scalar()
self.assertEqual(response6.status_code, 409)
self.assertFalse(exists6)
self.assertIn('Provide strong password', str(response6.data))